Blog de Matthieu MEZIL » VB

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

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.

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

VS 2008 Beta 2 – En attendant la RTM

Matthieu MEZIL — Sat, 03 Nov 2007 22:22:53 +0000

Si vous utilisez la Beta 2, vous avez sûrement eu le même problème que moi : la version expire au 1er novembre
Il faut retélécharger les images pour ne plus avoir de limitation.

Update LINQ To SQL : toutes les colonnes, non pas forcément

Matthieu MEZIL — Sun, 28 Oct 2007 19:05:31 +0000

J’avais blogué sur le fait que le Update de LINQ To SQL se faisait sur toutes les colonnes, y compris celles qui n’ont pas changés, ce qui peut poser des problèmes si vous avez des triggers sur le update de la table SQL.
En réalité, j’avais bloggué un peu vite. En effet, de même qu’il est possible de ne charger des colonnes qu’au moment de l’utilisation de la propriété associée (Delay Loaded = true) avec System.Data.Linq.Link, il est possible de ne pas inclure une colonne à l’update si celle-ci n’a pas été modifiée avec l’attribut UpdateCheck=UpdateCheck.WhenChanged.

Vous pouvez retrouver Delay Loaded et Update Check dans la property grid du designer LINQ To SQL.