Blog de Matthieu MEZIL

Article .NET 3.5

Matthieu MEZIL — Fri, 14 Dec 2007 21:05:16 +0000

Vous trouverez dans le hors série .net de Programmez un article « Plongée au coeur de .Net 3.5″ co-écrit avec Michel Perfetti.
Bonne lecture

C# 3.0 Créer une liste de types anonymes

Matthieu MEZIL — Sat, 31 Mar 2007 22:18:02 +0000

Dans mon article sur le C# 3.0, j’avais regretté le fait de ne pouvoir créer de list de type anonyme.
Cependant, en me repenchant sur le sujet, j’ai trouvé une feinte :

var test = new { PropertyStr = "un", PropertyInt = 1 };
var list = Activator.CreateInstance(Type.GetType("System.Collections.Generic.List`1[" + test.GetType().ToString() + "]")) as IList;
list.Add(test);
list.Add(new { PropertyStr = "deux", PropertyInt = 2 });

Ensuite, pour récupérer la valeur des propriétés de notre anonymous type pour les éléments de la liste, on peut utiliser la reflection ou alors il faut encore feinter :

static void Main(string[] args)
{
var test = new { PropertyStr = "un", PropertyInt = 1 };
var list = Activator.CreateInstance(Type.GetType("System.Collections.Generic.List`1[" + test.GetType().ToString() + "]")) as IList;
list.Add(test);
list.Add(new { PropertyStr = "deux", PropertyInt = 2 });

foreach (object o in list)
{
var v = Cast(test, o);
Console.WriteLine(v.PropertyInt.ToString() + " " + v.PropertyStr);
}
Console.ReadLine();
}

public static T Cast(T typedValue, object value)
{
return (T)value;
}

J’espère cependant toujours que l’on puisse créer des listes de type anonyme dans la version finale. Le code pourrait alors ressemblait à ça :

VS 2008 dispo sur msdn !!!

Matthieu MEZIL — Mon, 19 Nov 2007 10:07:36 +0000

L’info est énorme !!!
VS 2008 est dispo dès à présent. Il faut juste avoir un compte msdn pour cela.
Bon téléchargement

Rename incomplete

Matthieu MEZIL — Tue, 13 Nov 2007 19:34:12 +0000

Imaginons le code suivant :

int i = 0;
#if DEBUG
i ++;
#else
i--;
#endif

Si je renomme i en j et que je laisse VS le renommer pour moi, j’obtiens le code suivant :

int j = 0;
#if DEBUG
j ++;
#else
i--;
#endif

Je comprends bien la difficulté évoquée par Michael Taylor sur le forum msdn mais je trouve que c’est regrettable.

MIX 2008

Matthieu MEZIL — Thu, 08 Nov 2007 23:24:53 +0000

Les inscriptions pour le MIX 2008 sont ouvertes.
Pour rappel, le MIX, c’est L‘évènement web MS annuel. Comme chaque année, il se fera à Las Vegas et sera ensuite relayé dans le monde entier (au cirque d’hiver de Paris l’année dernière par ex). Cette année, il aura lieu du 5 au 7 mars 2008 au Resort Hotel Casino, Las Vegas, Nevada.

VB et les Optional

Matthieu MEZIL — Thu, 08 Nov 2007 07:09:56 +0000

Les paramètres optional ne peuvent pas être de type structure. Par conséquent, les nullables ne sont pas autorisés

LINQ Select VB != Select C# quand on fait un select sur un type anonyme

Matthieu MEZIL — Sat, 13 Oct 2007 07:48:10 +0000

Imaginons une classe Personne avec plusieurs propriétés telles que le Nom, Prenom, DateNaissance, Adresse, etc.

Pour créer un type anonyme en C#, il suffit de faire :

new { Nom = p.Nom, Prenom = p.Prenom }

Dans ce cas, les noms des propriétés étant les mêmes, on pourra même directement écrire :

new { p.Nom, p.Prenom }

De la même manière, en VB, il suffit d’écrire

New With { p.Nom, p.Prenom }

Si vous voulez faire une requête LINQ et ne renvoyer que le nom et le prénom, il faut utiliser un type anonyme.

Fort logiquement, en C#, il faut faire :

from p in persons select new {p.Nom, p.Prenom}

En VB, le type anonyme va être créé pour nous avec l’écriture suivante (plus proche du SQL) :

from p in persons select p.Nom, p.Prenom

LINQ : attention à bien l’utiliser

Matthieu MEZIL — Sat, 03 Nov 2007 20:42:55 +0000

Le défaut de LINQ c’est qu’il va devenir beaucoup plus facile de faire du code moins performant.
Prenons un exemple :

public class Client
{
private List _factures;

public string Nom { get; set; }
public string Prenom { get; set; }
public List Factures
{
get
{
if (_factures == null)
_factures = new List();
return _factures;
}
}
}

public class Facture
{
private Client _client;

public Client Client
{
get { return _client; }
set
{
if (_client != null)
_client.Factures.Remove(this);
_client = value;
_client.Factures.Add(this);
}
}
public decimal Prix { get; set; }
}

Imaginons que l’on veuille récupérer les clients ayant dépensé au moins 50 euros en les triant par ordre décroissant de dépense, puis alphabétiquement.

Le code en C# 2.0 pourrait être le suivant :

List copyClients = new List();
copyClients.AddRange(clients);

copyClients.Sort(delegate(Client x, Client y)
{
decimal xFacturesSomme = 0, yFacturesSomme = 0;
foreach (Facture facture in x.Factures)
xFacturesSomme += facture.Prix;
foreach (Facture facture in y.Factures)
yFacturesSomme += facture.Prix;
int compareFactureSomme = xFacturesSomme.CompareTo(yFacturesSomme);
if (compareFactureSomme != 0)
return -compareFactureSomme;
int compareNom = x.Nom.CompareTo(y.Nom);
if (compareNom != 0)
return compareNom;
return x.Prenom.CompareTo(y.Prenom);
});
foreach (Client c in copyClients)
{
decimal facturesSomme = 0;
foreach (Facture facture in c.Factures)
facturesSomme += facture.Prix;
if (facturesSomme > 50)
Console.WriteLine("{0} {1} a dépensé {2} euros", c.Nom, c.Prenom, facturesSomme);
}

Avec LINQ, ce code peut être grandement simplifié. Mais attention, on pourrait écrire ceci :

foreach (var statClient in from c in
(from client in clients
select new
{
client.Nom,
client.Prenom,
TotalDepense = (from f in client.Factures
select f.Prix).Sum()
})
where c.TotalDepense > 50
orderby c.TotalDepense descending, c.Nom, c.Prenom
select c)
Console.WriteLine("{0} {1} a dépensé {2} euros", statClient.Nom, statClient.Prenom, statClient.TotalDepense);

Cependant, analysons de plus près ce code :

Pour calculer la somme totale dépensée par le client, nous parcourons toutes les factures pour récupérer un IEnumerable sur le prix de celles-ci, puis nous reparcourons cet IEnumerable pour faire la somme.

L’idée serait donc de regrouper ces deux boucles en une seule. Pour cela, utilisons une lambda expression et une autre signature de la méthode Sum :

foreach (var statClient in from c in
(from client in clients
select new
{
client.Nom,
client.Prenom,
TotalDepense = client.Factures.Sum(f => f.Prix)
})
where c.TotalDepense > 50
orderby c.TotalDepense descending, c.Nom, c.Prenom
select c)
Console.WriteLine("{0} {1} a dépensé {2} euros", statClient.Nom, statClient.Prenom, statClient.TotalDepense);

L’autre problème que l’on peut identifier, c’est le fait que nous parcourons une première boucle sur les clients pour récupérer un IEnumerable de type anonyme avec le nom, le prénom et la somme dépensée et qu’ensuite, nous reparcourons cet IEnumerable pour les trier. Effectivement, pour pouvoir trier par la somme dépensée, il faut au préalable l’avoir calculée.

Là encore, une meilleure utilisation de LINQ pourrait nous permettre d’optimiser cela :

foreach (var statClient in from c in clients
let totalDepense = c.Factures.Sum(f => f.Prix)
where totalDepense > 50
orderby totalDepense descending, c.Nom, c.Prenom
select new
{
c.Nom,
c.Prenom,
TotalDepense = totalDepense
})
Console.WriteLine("{0} {1} a dépensé {2} euros", statClient.Nom, statClient.Prenom, statClient.TotalDepense);

Via ce post, je cherche à démontrer deux choses :
la requête LINQ est beaucoup plus simple et claire que le code C# 2.0.
une mauvaise connaissance de LINQ peut engendrer des pertes de performances importantes.

En revanche, avec LINQ To SQL, même si je ne vous conseille bien entendu pas d’écrire de « mauvaises » requêtes, la requête SQL générée est optimisée. Dans les trois cas précédents, la requête sera la suivante :

SELECT [t2].[Nom], [t2].[Prenom], [t2].[value] AS [TotalDepense]
FROM (
SELECT [t0].[Nom], [t0].[Prenom], (
SELECT SUM([t1].[Prix])
FROM [dbo].[Facture] AS [t1]
WHERE [t1].[Client] = [t0].[Id]
) AS [value]
FROM [dbo].[Client] AS [t0]
) AS [t2]
WHERE [t2].[value] > @p0
ORDER BY [t2].[value] DESC, [t2].[Nom], [t2].[Prenom]

Le risque lié à une mauvaise connaissance de LINQ peut cependant être fortement réduit avec une formation (http://www.winwise.fr/formation/Presentation-de-LINQ-W095.aspx par exemple).

Extension method : C# différent de VB

Matthieu MEZIL — Wed, 07 Nov 2007 07:05:51 +0000

Dans l’excellent article de Adrian « Spotty » Bowles paru dans le msdn mag sur les extension methods en VB, l’auteur nous explique que ce code :

Imports System.Runtime.CompilerServices

Module Module1
Sub Main()
Dim s As Integer = 1234
Console.WriteLine(s.Foo) '<- This will work

Dim T As Object
T = 1234
Console.WriteLine(T.Foo) '<- This will fail
End Sub
End Module

Module Extensions01
_
Function Foo(ByVal b As Object) As String
Return "Bar01"
End Function
End Module

génère une exception à la compilation et c’est vrai !

Mais pas en C#.

Le code suivant marche en effet très bien :

class Program
{
static void Main(string[] args)
{
object o;
o = 10;
Console.WriteLine(o.Foo());
Console.ReadLine();
}
}

static class Ext
{
public static string Foo(this object o)
{
return "test";
}
}

VS 2008 sortie fin novembre

Matthieu MEZIL — Mon, 05 Nov 2007 22:33:25 +0000

C’est officiel, VS 2008 sortira fin novembre. Que du bonheur en perspective