Jérôme Lambert » Linq

#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).

#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).

#3 Les opérateurs de requête Linq de Aggregate à Where : Reverse

Jérôme Lambert — Tue, 11 Aug 2009 00:48:24 +0000

Si vous cherchiez une logique dans l’ordre que j’utilise pour présenter les opérateurs Linq, ne cherchez plus, il n’y en a aucun (ou presque étant donné que certains opérateurs sont dépendants d’autres opérateurs). Mais excepté ces quelques exceptions, il ne s’agit que d’un bon vieux random pour déterminer l’ordre dans lequel j’allais aborder les opérateurs. Maintenant que tout est dit et que l’on ne cache plus rien du tout, on va passer au sujet principal qui est l’opérateur Reverse.

On reprend notre classe MembreDeveloppez qui nous suit depuis le début :

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

Et maintenant, on va considérer que nous avons toujours une liste d’instance de la classe MembreDeveloppez et imaginons que l’on désire obtenir une nouvelle liste avec les mêmes éléments mais dans l’ordre inverse. Vous pensez de suite à ceci ?

membres.Reverse();

C’est faux ! J’ai bien demandé une nouvelle instance alors que dans le cas précédent, c’est la liste originale qui est altérée Bon, blague à part, vous avez surement imaginez le code suivant :

List<MembreDeveloppez> membres = GetMembresDeveloppez();
List<MembreDeveloppez> membresReverse = new List<MembreDeveloppez>();

for (int i = membres.Count; i > 0; i–)
{
membresReverse.Add(membres[i – 1]);
}

Je vais même vous faire une confidence qui a tout son sens dans le sujet actuel : même si je savais comment inverser les éléments de ma liste, j’ai quand même passé 5 minutes à corriger mes erreurs d’index pour cet exemple

Tout ça pour dire qu’évidemment avec l’opérateur Reverse de Linq, c’est non plus 5 minutes qu’il vous faudra mais bien 5 secondes (pour les plus rapides bien sûr).

var result = membres.Reverse<MembreDeveloppez>();

Le temps de taper la ligne de code.

Evidemment, j’ai un peu tricher car Reverse me renvoie non pas une instance de List mais un IEnumerable. Un autre opérateur pourrait résoudre ce dernier point mais pour en savoir plus, il vous faudra encore un peu attendre.

A la prochaine

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

A voir aussi :

#2 Les opérateurs de requête Linq de Aggregate à Where : First & FirstOrDefault

Jérôme Lambert — Fri, 07 Aug 2009 00:48:15 +0000

Nous voila pour le second billet sur les opérateurs Linq et pour aujourd’hui, j’aimerais aborder deux opérateurs qui se ressemblent fort : First & FirstOrDefault. Pour l’occasion, j’en ai profité pour créer une solution Visual Studio 2008 qui sera mise à jour après chaque billet. Vous retrouverez le zip de la solution en fin d’article.

On va reprendre notre « classe » MembreDeveloppez que j’ai un peu étoffé pour l’occasion :

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

Et toujours sur le même principe qu’avant, on va considérer que nous avons une liste d’instances de la classe MembreDeveloppez (donc ).

Alors maintenant, dîtes-moi comment vous feriez pour récupérer le premier élément de cette liste en sachant qu’il y a au moins un élément dedans ?

MembreDeveloppez membre1 = membres[0];

Vous avez pensé à ça ? Pas mal. Personnellement, je fais comme ceci avec l’opérateur First de Linq :

MembreDeveloppez membre1 = membres.First();

Impressionnant, n’est-ce pas ?! Non ??? Admettons, un point pour vous, on peut dire que cet opérateur n’apporte pas grand chose dans notre cas. Cependant, je me demande bien comment vous faîtes pour récupérer le premier objet dans la liste qui a un nombre de message supérieur à 2000 ?

Pour la majorité d’entre vous, vous feriez comme ceci ?

foreach (MembreDeveloppez membre in membres)
{
        if (membre.NombreMessages > 2000)
        {
                // Trouvé !
        }
}

Dans ce cas-ci et toujours avec l’opérateur First, une ligne de code !

MembreDeveloppez membre1 = membres.First(membre => membre.NombreMessages > 2000);

Aaaahhh, c’est mieux quand même ! Et si on corsait légèrement l’énoncé en disant qu’il est possible que notre liste n’ait aucun élément. Pour vous, on va dire que ça ne change rien mais dans le cas de l’opérateur First, on risque de recevoir une exception si notre liste est vide ou bien si la condition n’est pas respectée. C’est là que l’opérateur FirstOrDefault va s’avérer utile car dans le cas où notre demande ne renvoie rien, on ne recevra pas une exception comme avec First mais tout simplement null.

MembreDeveloppez membre2 = membres.FirstOrDefault(membre => membre.NombreMessages > 100000);

On va s’arrêter là pour aujourd’hui, Bon Linq

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

A voir aussi :

L’opérateur Any