Jérôme Lambert » C#

Article : les nouveautés de C# 5.0

Jérôme Lambert — Wed, 22 Aug 2012 08:44:19 +0000

Voila un court billet pour relayer mon dernier article publié sur developpez.com et qui est consacré aux nouveautés de C# 5.0. Vous pourrez y découvrir les deux principales nouveautés que sont await/async et les attributs Caller Information.

Suite à l’actualité de la semaine dernière, n’oubliez pas que Microsoft a mis à disposition la version finale, RTM, de Visual Studio 2012.

Télécharger Visual Studio 2012 express et trial gratuitement !

Bonne lecture et bons tests !

#4 Les opérateurs de requête Linq de Aggregate à Where : SequenceEqual

Jérôme Lambert — Sun, 27 Sep 2009 23:00:00 +0000

C’est officiel, les vacances sont finies et donc retour difficile à la réalité mais c’est quand même avec grand plaisir que je reprends du service avec cette série d’astuces sur Linq Pour recommencer, on va y aller en douceur en abordant l’opérateur SequenceEqual.

Alors. Comment faîtes-vous pour déterminer si deux listes ont les mêmes éléments ? (je parle bien des mêmes instances)

Quelque chose comme ceci ?

var membres1 = GetMembresDeveloppez();
var membres2 = GetMembresDeveloppez();

if (membres1.Count == membres2.Count)
{
        foreach (var currentMembre in membres1)
        {
                if (membres2.Contains(currentMembre) == false)
                        return false;
        }

return true;
}
else
{
return false;
}

Avec Linq, l’opérateur SequenceEqual s’occupera de faire toute la comparaison pour vous :

var membres1 = GetMembresDeveloppez();
var membres2 = GetMembresDeveloppez();

bool result1 = membres1.SequenceEqual(membres2); // Faux
bool result2 = membres1.SequenceEqual(membres1); // Vrai
bool result3 = membres1.SequenceEqual(membres1.ToList()); // Vrai

Facile ?

Téléchargez les sources (sous Visual Studio 2008).

Nouvel article : Présentation de la classe Tuple du .NET Framework 4

Jérôme Lambert — Tue, 12 Jan 2010 09:07:27 +0000

Avec l’arrivée du .NET Framework 4 de Microsoft, de nombreuses classes ont été introduites. Une de ces classes est la classe « System.Tuple » et qui permet de stocker un ensemble d’éléments de types différents tout en gardant une sécurité au niveau du typage grâce à la généricité. L’avantage est que vous allez pouvoir utiliser ce type en retour ou comme argument de vos méthodes. Les développeurs Python devraient déjà comprendre de quoi je parle. Pour les autres, vous pourrez découvrir cette classe plus en détails dans le dernier article que je viens d’écrire et qui s’intitule « Présentation de la classe Tuple du .NET Framework 4« .

Bonne lecture !

#9 Les opérateurs de requête Linq de Aggregate à Where : Single & SingleOrDefault

Jérôme Lambert — Sun, 11 Oct 2009 23:30:50 +0000

Aujourd’hui pour bien commencer la semaine, on va aborder deux opérateurs que j’affectionne tout particulièrement : Single et SingleOrDefault.

Pour ces opérateurs, on va devoir préciser notre classe MembreDeveloppez en y ajoutant un champ ID qui représente un identifiant unique pour chaque membre de developpez.com.

public class MembreDeveloppez : IComparable<MembreDeveloppez>
{
        public int ID { get; set; }
        public string Nom { get; set; }
        public int NombreMessages { get; set; }

// …
}

Et au passage, voici la nouvelle implémentation de la méthode GetMembresDeveloppez() qui (pour ceux qui n’auraient pas suivi) retourne une liste d’instances de la classe MembreDeveloppez :

public static List<MembreDeveloppez> GetMembresDeveloppez()
{
        return new List<MembreDeveloppez>()
        {
                new MembreDeveloppez(){ ID=1, Nom=« Jérôme Lambert », NombreMessages = 3000},
                new MembreDeveloppez(){ ID=2, Nom=« Louis-Guillaume Morand », NombreMessages = 2500},
                new MembreDeveloppez(){ ID=3, Nom=« Aspic », NombreMessages = 1200},
                new MembreDeveloppez(){ ID=4, Nom=« Dev01″, NombreMessages = 530},
                new MembreDeveloppez(){ ID=5, Nom=« Giovanny Temgoua », NombreMessages = 8300},
                new MembreDeveloppez(){ ID=6, Nom=« LefortLudovic », NombreMessages = 1200},
                new MembreDeveloppez(){ ID=7, Nom=« nico-pyright(c) », NombreMessages = 660},
                new MembreDeveloppez(){ ID=8, Nom=« Skyounet », NombreMessages = 4300},
                new MembreDeveloppez(){ ID=9, Nom=« Smyley », NombreMessages = 2200}
                // …
        };
}

Maintenant la question du jour : comment feriez-vous pour récupérer un membre de developpez.com sur base de son identifiant ? On va prendre comme exemple le membre Skyounet avec l’identifiant 8.

J’ai l’impression que certains, qui ont suivi cette série de billets depuis le début, ont envie de proposer une solution avec l’opérateur First (voir FirstOrDefault) :

var membres = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();

SampleLibrary.MembreDeveloppez membreID8 = membres.First(membre => membre.ID == 8);

Et bien pas de chance mais ce n’est pas tout à fait juste car on parle bien d’identifiant unique. Or avec l’opérateur First (ou FirstOrDefault), on récupère que le premier élément de la séquence résultante, or, si notre séquence venait à contenir plus d’un membre avec l’identifiant 8, il y aurait un réel problème au niveau de l’intégrité de vos données et pire encore, vous auriez fermé les yeux face à ce cas.

Le code suivant va donc s’exécuter correctement mais vous passerez à côté du fait que deux membres ont l’identifiant 8 :

var membres = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();
membres.Add(new SampleLibrary.MembreDeveloppez() { ID = 8, Nom = « Inconnu numéro 8″, NombreMessages = 0 });

SampleLibrary.MembreDeveloppez membreID8 = membres.First(membre => membre.ID == 8);

C’est là que notre opérateur Single va être intéressant car il renverra une exception dans deux cas :

Lorsqu’il n’y aura pas d’élément dans notre résultat (comme avec First d’ailleurs)
Lorsqu’il y aura plus d’un élément dans notre résultat !

Le second cas répond donc exactement à notre problématique :

var membres = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();
membres.Add(new SampleLibrary.MembreDeveloppez() { ID = 8, Nom = « Inconnu numéro 8″, NombreMessages = 0 });

try
{
        SampleLibrary.MembreDeveloppez membreID7 = membres.Single(membre => membre.ID == 7);
        //SampleLibrary.MembreDeveloppez membreID8 = membres.Single(membre => membre.ID == 8); // => Génère une exception
        Console.WriteLine(« Le membre avec l’identifiant 8 est {0} », membreID7.Nom);
}
catch (System.Exception exc)
{
        Console.WriteLine(« La requête n’a pas renvoyé un et un seul membre. »);
}

Pour ce qui est de l’opérateur SingleOrDefault, il se comporte comme Single excepté le fait qu’il renverra null lorsque le résultat n’aura pas d’élément (contrairement à Single qui génèrera une exception).

try
{
        SampleLibrary.MembreDeveloppez membreID1000 = membres.SingleOrDefault(membre => membre.ID == 1000);
        if (membreID1000 != null)
        {
                Console.WriteLine(« Le membre avec l’identifiant 1000 est {0} », membreID1000.Nom);
        }
        else
        {
                Console.WriteLine(« Il n’existe pas de membre avec l’identifiant 1000. »);
        }
}
catch (System.Exception exc)
{
        Console.WriteLine(« La requête n’a pas renvoyé un et un seul membre. »);
}

Alors fan ou pas ?!

Téléchargez les sources (sous Visual Studio 2008).

#11 Les opérateurs de requête Linq de Aggregate à Where : Concat

Jérôme Lambert — Tue, 13 Oct 2009 23:58:04 +0000

On entame le milieu de la semaine et pour se motiver un peu plus, rien de tel qu’un second billet sur les opérateurs Linq et en plus, ça ne va pas être compliqué. L’opérateur de ce billet est Concat !

Imaginez que vous avez deux listes et que vous désirez n’en faire qu’une seule qui regrouperait les éléments de la première liste avec les éléments de la seconde liste : comment procéderiez-vous ?

Le facile est surement d’utiliser la méthode AddRange disponible sur une liste, ainsi vous avez surement pensez à quelque chose de ce genre :

List<SampleLibrary.MembreDeveloppez> listeMembres1 = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();
List<SampleLibrary.MembreDeveloppez> listeMembres2 = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();

List<SampleLibrary.MembreDeveloppez> listeMembreResult = new List<SampleLibrary.MembreDeveloppez>();

listeMembreResult.AddRange(listeMembres1);
listeMembreResult.AddRange(listeMembres2);

Grâce à la méthode Concat de Linq, vous allez pouvoir concaténer deux listes d’objets pour n’en faire qu’une seule. Je dis liste mais ça fonctionnerait avec n’importe quelle collection/séquence tant qu’elle implémente IEnumerable ou IEnumerable.

var query = listeMembres1.Concat(listeMembres2);

List<SampleLibrary.MembreDeveloppez> listeMembresResult1 = query.ToList();

Comme vous pouvez le remarquer, j’ai utilisé l’opérateur ToList (que nous avons déjà vu lors d’un autre billet) après l’opérateur Concat pour obtenir mes objets dans une liste. La raison est que l’opérateur Concat renvoie un IEnumerable. En fait pour être plus précis, on récupère un ConcatIterator.

L’opérateur Concat ne crée donc pas directement une séquence avec le bon résultat mais va tout simplement s’occuper de mémoriser les séquences à concaténer et ce n’est qu’à la demande que le résultat sera exécuté (par exemple lors d’un foreach ou comme dans notre cas lors de l’utilisation de l’opérateur ToList. On appelle ça l’exécution différée.

Pour le prouver, on va modifier légèrement le code pour ajouter un nouvel élément dans listeMembre1 après avoir créé la requête de concaténation.

var query = listeMembres1.Concat(listeMembres2);

List<SampleLibrary.MembreDeveloppez> listeMembresResult1 = query.ToList();

listeMembres1.Add(new SampleLibrary.MembreDeveloppez() { Nom = « Marc Lussac », NombreMessages = 23000 });

List<SampleLibrary.MembreDeveloppez> listeMembresResult2 = query.ToList();

Si vous essayez ce code, vous vous apercevrez que listeMembresResult2 contient un élément de plus que listeMembresResult1.

Je pense que pour un opérateur dit facile, on est allé assez dans le détail.

Rendez-vous au prochain numéro !

Téléchargez les sources (sous Visual Studio 2008).

#10 Les opérateurs de requête Linq de Aggregate à Where : ToArray & ToList

Jérôme Lambert — Tue, 13 Oct 2009 23:47:28 +0000

Ca y est, nous venons de franchir le 10e billet de la série « Les opérateurs de requête Linq de Aggregate à Where« . Je suis assez satisfait de voir que ça avance mais il reste encore pas mal d’opérateurs à voir ! Ne perdons pas de temps et pour aujourd’hui, nous allons aborder les opérateurs ToArray & ToList.

Prenons le cas de notre liste d’instances de la classe MembreDeveloppez :

List<SampleLibrary.MembreDeveloppez> membres = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();

Comment feriez-vous pour transférer vos instances dans un tableau ? (le tableau étant un MembreDeveloppez[])

Par exemple, vous pourriez avoir pensé à ce code :

SampleLibrary.MembreDeveloppez[] membresToArray = new SampleLibrary.MembreDeveloppez[membres.Count];
for (int i = 0; i < membres.Count; i++)
{
membresToArray[i] = membres[i];
}

Et bien, il y a beaucoup plus simple à présent grâce à l’opérateur ToArray ! Fini les boucles, une seule ligne de code sera nécessaire :

SampleLibrary.MembreDeveloppez[] membresToArray = membres.ToArray();

Et le contraire est possible grâce à l’opérateur ToList qui vous permettra d’obtenir une liste typée (dans notre cas nous aurons List).

List<SampleLibrary.MembreDeveloppez> membresToList = membresToArray.ToList();

A chaque utilisation de ToArray ou ToList, c’est une nouvelle instance de tableau ou de liste typée qui est instanciée et évidemment, les éléments contenus sont les mêmes que dans la séquence source (ce sont donc les mêmes références). Si vous ne m’avez pas compris, regardez le bout de code ci-dessous :

List<SampleLibrary.MembreDeveloppez> membres = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();

Console.WriteLine(« Est-ce que la liste source est la même que la liste créée avec l’opérateur ToList ? {0} », membres == membres.ToList());
Console.WriteLine(« Est-ce que le premier élément de la liste source est le même que celui de la liste créée avec l’opérateur ToList ? {0} », membres[0] == membres.ToList()[0]);

Ce qui donnera à l’exécution :

Est-ce que la liste source est la même que la liste créée avec l’opérateur ToList ? False
Est-ce que le premier élément de la liste source est le même que celui de la liste créée avec l’opérateur ToList ? True

Sachez aussi que les opérateurs (comme d’ailleurs tous les autres opérateurs Linq) peuvent être utilisés sur n’importe quelles collections d’objets à condition qu’elle implémente l’interface IEnumerable.

Bon Linq !

Téléchargez les sources (sous Visual Studio 2008).

#8 Les opérateurs de requête Linq de Aggregate à Where : Last & LastOrDefault

Jérôme Lambert — Tue, 06 Oct 2009 00:03:05 +0000

Ne dîtes rien, je vous entends déjà dire : « Oh non, pas encore lui avec son Steve Ballmer qui sera là demain à Paris ! Y en a marre d’entendre la même musique !!!« . Et vous avez raison ! Rassurez-vous, ce n’est pas cette histoire qui va nous empêcher de parler des opérateurs Linq et plus particulièrement des opérateurs Last & LastOrDefault.

Vu que c’est le début de la semaine, je vais faire un petit rappel sur notre fameuse classe MembreDeveloppez qui depuis le temps a continuer d’évoluer :

public class MembreDeveloppez : IComparable<MembreDeveloppez>
{
        // …
        public string Nom { get; set; }
        public int NombreMessages { get; set; }

        public int CompareTo(MembreDeveloppez other)
        {
                return this.NombreMessages.CompareTo(other.NombreMessages);
        }
}

Vous allez voir que ce nous allons aborder est assez similaire à deux opérateurs que nous avons déjà vu précédemment.

Nous avons toujours une liste d’instances de la classe MembreDeveloppez et dîtes-moi comment vous feriez pour récupérer le dernier élément de cette liste ? En sachant qu’il est y a au moins un élément dans cette liste.

Un Exemple :

SampleLibrary.MembreDeveloppez membre = membres[membres.Count – 1];

Avec l’opérateur Last, vous allez pouvoir obtenir le même résultat :

SampleLibrary.MembreDeveloppez membre1 = membres.Last();

A la limite un peu moins de lettres à écrire mais on a déjà vu mieux comme évolution. Par contre, comment feriez-vous pour récupérer dans notre liste le dernier membre de Developpez.com qui a écrit au moins 3000 messages ?

Un cas possible :

SampleLibrary.MembreDeveloppez membre = null;
foreach (var currentMembre in membres)
{
        if (currentMembre.NombreMessages >= 3000)
        {
                membre = currentMembre;
        }
}
Console.WriteLine(« {0} est le dernier membre de notre liste qui a écrit au moins 3000 messages. », membre.Nom);

Avec l’opérateur Last, on va pouvoir le faire en une seule ligne de code !

SampleLibrary.MembreDeveloppez membre2 = membres.Last(membre => membre.NombreMessages >= 3000);

Personnellement, c’est le style d’écriture que j’adore : claire et concise.

Enfin, on va voir une dernière chose car pour rappel, il nous reste encore à illustrer l’utilisation de l’opérateur LastOrDefault. Si on change la contrainte de départ en considérant que notre liste pourrait être vide. Ou bien que la condition ne renvoie aucun résultat. Avec Last, on recevra une exception mais avec LastOrDefault, on récupérera la valeur nulle.

SampleLibrary.MembreDeveloppez membre3 = membres.LastOrDefault(membre => membre.NombreMessages > 100000);

C’est tout pour aujourd’hui !

J’oubliais de vous dire. Dans quelques heures, Steve Ballmer répondra à vos questions lors des Microsoft Days à Paris dès 10h. Et pour ceux qui ne pourront pas être présent à la conférence, l’interview sera retransmise en direct via Live Meeting !

Téléchargez les sources (sous Visual Studio 2008).

#7 Les opérateurs de requête Linq de Aggregate à Where : Min & Max

Jérôme Lambert — Fri, 02 Oct 2009 00:37:00 +0000

Et oui ! Je me suis sûrement très bien reposé (trop ?) pendant les vacances et c’est pour ça que j’attaque un second billet le même jour ! On va même découvrir deux opérateurs en même temps : Min et Max.

Encore et toujours avec la classe MembreDeveloppez, comment feriez-vous pour récupérer le nombre maximum de messages écrits par un membre ?

Un exemple :

int maxMessages = 0;
foreach (var currentMembre in membres)
{
        if (maxMessages < currentMembre.NombreMessages)
        {
                maxMessages = currentMembre.NombreMessages;
        }
}

Console.WriteLine(« Nombre maximum de messages écrits : {0} », maxMessages);

Avec les opérateurs Linq, on va tout simplement utiliser Max sur notre liste de membres :

int maxMessages = membres.Max(membre => membre.NombreMessages);

Console.WriteLine(« Nombre maximum de messages écrits : {0} », maxMessages);

Le hic dans la solution avec l’opérateur Max, c’est qu’on n’obtient pas le membre de developpez.com qui a écrit le plus de messages. Du moins, ce n’est pas possible avec cette surcharge de l’opérateur Max. En fait, il est possible de récupérer l’instance MembreDeveloppez en utilisant la surcharge de Max sans aucun argument. Evidemment, il faudra implémenter l’interface IComparable au niveau du la classe MembreDeveloppez pour que la comparaison puisse se faire correctement.

On aura donc pour la classe MembreDeveloppez :

public class MembreDeveloppez : IComparable<MembreDeveloppez>
{
        // …
        public string Nom { get; set; }
        public int NombreMessages { get; set; }

        public int CompareTo(MembreDeveloppez other)
        {
                return this.NombreMessages.CompareTo(other.NombreMessages);
        }
}

Et au final, nous aurons :

SampleLibrary.MembreDeveloppez membreLePlusBavard = membres.Max();

Console.WriteLine(« Le membre le plus bavard est {0} avec {1} messages. », membreLePlusBavard.Nom, membreLePlusBavard.NombreMessages);

Et l’opérateur Min dans tout ça ? J’ai honte de montrer un exemple mais par principe, je vais quand même le faire Donc avec l’opérateur, on va tout simplement pouvoir récupérer la valeur minimale dans notre collection comme ceci :

int minMessages = membres.Min(membre => membre.NombreMessages);

Console.WriteLine(« Nombre minimum de messages écrits : {0} », minMessages);

SampleLibrary.MembreDeveloppez membreLePlusDiscret = membres.Min();

Console.WriteLine(« Le membre le plus discret est {0} avec {1} messages. », membreLePlusDiscret.Nom, membreLePlusDiscret.NombreMessages);

Allez, c’est définitivement fini pour aujourd’hui !

Et bon week end d’avance

Téléchargez les sources (sous Visual Studio 2008).

#6 Les opérateurs de requête Linq de Aggregate à Where : Average

Jérôme Lambert — Fri, 02 Oct 2009 00:04:34 +0000

Ca y est, il commence à y avoir un ordre cohérent dans la série des billets sur les opérateurs Linq qui vont suivre. Encore quelques ajustements et ce sera bon. En attendant, on va rester dans la lignée de l’opérateur Sum que nous avons vu dans le numéro 5 et attaquer l’opérateur Average.

On reprend notre liste d’instances de la classe MembreDeveloppez et dîtes-moi comment vous feriez-vous pour obtenir la moyenne globale des messages écrits par les membres de developpez.com ?

Facile ?! Je me doute

int totalMessages = 0;
foreach (var currentMembre in membres)
{
totalMessages += currentMembre.NombreMessages;
}

Console.WriteLine(« Nombre de messages moyen : {0} », (double)totalMessages / membres.Count);

Avec Linq, vous avez un opérateur qui fait tout ça pour vous : Average.

Ce qui nous donne :

double moyenneMessage = membres.Average(membre => membre.NombreMessages);

Console.WriteLine(« Nombre de messages moyen : {0} », moyenneMessage);
Console.Read();

Et tout comme avec l’opérateur Sum, vous pourrez utiliser cet opérateur pour calculer une moyenne avec les types suivants : int, int?, float, float?, decimal, decimal?, double, double?, long et long?.

Bon Linq !

Téléchargez les sources (sous Visual Studio 2008).

#5 Les opérateurs de requête Linq de Aggregate à Where : Sum

Jérôme Lambert — Tue, 29 Sep 2009 23:55:23 +0000

Avant de commencer cette série de billets sur Linq, j’avais décidé d’aborder les opérateurs dans un ordre aléatoire. Plus, je regarde cet ordre aléatoire et plus je me dis qu’il va falloir remettre un ordre la dedans car il y a pas mal d’opérateurs qu’il n’est pas possible d’aborder sans en avoir vu d’autres au préalable. Enfin soit, aujourd’hui, on reste dans le facile avec l’opérateur Sum.

On reprend notre classe MembreDeveloppez que voici :

public class MembreDeveloppez
{
        // …
        public string Nom { get; set; }
        public int NombreMessages { get; set; }
}

Si vous aviez une liste d’instances de cette classe, comment feriez-vous pour obtenir le nombre de message écrits par l’ensemble des membres de Developpez.com ?

Cette solution par exemple :

foreach (var currentMembre in membres)
{
totalMessage += currentMembre.NombreMessages;
}

Console.WriteLine(« Nombre de messages : {0} », totalMessage);

Encore une fois, il existe à présent un opérateur qui le fait déjà pour nous : Sum.

A présent, stop aux boucles qui font perdre du temps à nous tous, fainéants développeurs que nous sommes.

int totalMessage = membres.Sum(membre => membre.NombreMessages);

Console.WriteLine(« Nombre de messages : {0} », totalMessage);

Vous pourrez d’ailleurs utiliser cet opérateur pour calculer une somme avec les types suivants : int, int?, float, float?, decimal, decimal?, double, double?, long et long?.

C’est tout pour aujourd’hui

Téléchargez les sources (sous Visual Studio 2008).