|
|
Catégorie: Linq
14/10/09
[.NET] #11 Les opérateurs de requête Linq de Aggregate à Where : Concat
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> 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<T>.
List<SampleLibrary.MembreDeveloppez> listeMembres2 = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();
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<T>. En fait pour être plus précis, on récupère un ConcatIterator<T>.
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.
List<SampleLibrary.MembreDeveloppez> listeMembres2 = SampleLibrary.MembreDeveloppez.GetMembresDeveloppez();
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 !
Vous devez être identifié pour poster un commentaire.
[.NET] #10 Les opérateurs de requête Linq de Aggregate à Where : ToArray & ToList
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 :
Comment feriez-vous pour transférer vos instances dans un tableau ? (le tableau étant un MembreDeveloppez[])
Par exemple, vous pourriez avoir pensé à ce code :
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 :
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<MembreDeveloppez>).
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 :
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<T>.
Bon Linq !
Vous devez être identifié pour poster un commentaire.
12/10/09
[.NET] #9 Les opérateurs de requête Linq de Aggregate à Where : Single & SingleOrDefault
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 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 :
{
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) :
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 :
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 :
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).
{
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 ?! :-)
Vous devez être identifié pour poster un commentaire.
06/10/09
[.NET] #8 Les opérateurs de requête Linq de Aggregate à Where : Last & LastOrDefault
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 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 :
Avec l'opérateur Last, vous allez pouvoir obtenir le même résultat :
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 :
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 !
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.
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 ! :-)
Vous devez être identifié pour poster un commentaire.
02/10/09
[.NET] #7 Les opérateurs de requête Linq de Aggregate à Where : Min & Max
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 :
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 :
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<T> au niveau du la classe MembreDeveloppez pour que la comparaison puisse se faire correctement.
On aura donc pour la classe 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 :
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 :
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 ;-)
Vous devez être identifié pour poster un commentaire.
[.NET] #6 Les opérateurs de requête Linq de Aggregate à Where : Average
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 :)
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 :
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 !
Vous devez être identifié pour poster un commentaire.
30/09/09
[.NET] #5 Les opérateurs de requête Linq de Aggregate à Where : Sum
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 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 :
{
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.
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 :)
Vous devez être identifié pour poster un commentaire.
28/09/09
[.NET] #4 Les opérateurs de requête Linq de Aggregate à Where : SequenceEqual
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 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 membres2 = GetMembresDeveloppez();
bool result1 = membres1.SequenceEqual(membres2); // Faux
bool result2 = membres1.SequenceEqual(membres1); // Vrai
bool result3 = membres1.SequenceEqual(membres1.ToList()); // Vrai
Facile ? :)
Vous devez être identifié pour poster un commentaire.
11/08/09
[.NET] #3 Les opérateurs de requête Linq de Aggregate à Where : Reverse
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 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 ?
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> 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).
Le temps de taper la ligne de code.
Evidemment, j'ai un peu tricher car Reverse me renvoie non pas une instance de List<MembreDeveloppez> mais un IEnumerable<MembreDeveloppez>. 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 :
Vous devez être identifié pour poster un commentaire.
07/08/09
[.NET] #2 Les opérateurs de requête Linq de Aggregate à Where : First & FirstOrDefault
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 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 <ListMembreDeveloppez>).
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 ?
Vous avez pensé à ça ? Pas mal. Personnellement, je fais comme ceci avec l'opérateur First de Linq :
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 ?
{
if (membre.NombreMessages > 2000)
{
// Trouvé !
}
}
Dans ce cas-ci et toujours avec l'opérateur First, une ligne de code !
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.
On va s'arrêter là pour aujourd'hui, Bon Linq ;-)
Téléchargez les sources (sous Visual Studio 2008).
A voir aussi :
Vous devez être identifié pour poster un commentaire.
04/08/09
[.NET] #1 Les opérateurs de requête Linq de Aggregate à Where : Any
"Les opérateurs de requête Linq de Aggregate à Where" est en quelque sorte un défi que je me lance où l'objectif est d'écrire un billet sur chaque opérateur (standard) de Linq qu'il existe dans le Framework .NET 3.5 afin de vous montrer comment on faisait avant et comment on peut faire la même chose à présent avec les opérateurs Linq. Je viens encore de jeter un oeil sur la liste des opérateurs référencés sur MSDN et il y en a environ 50 *aie*. La tâche risque d'être longue mais je vais essayer de m'y tenir et puis si c'est pas le cas, j'espère bien que certains d'entre vous seront là pour me remotiver :-)
Après ce petit discours d'introduction, passons aux choses sérieuses avec l'opérateur Any. C'est un choix d'avoir voulu commencer par celui-là, car à mon sens, il incarne très bien la facilité que sont supposés apporter les opérateurs de Linq.
On va prendre un exemple tout simple et dîtes-moi comment vous faites pour tester qu'une collection a au minimum un élément ?
Comme ceci ?
if (membres.Count > 0)
{
// ...
}
Depuis le Framework .NET 3.5, je fais comme ceci :-)
if (membres.Any())
{
// ...
}
La différence, c'est qu'en utilisant la propriété Count, chaque élément de la collection est parcouru afin de déterminer le nombre d'élément existants. Pourtant, dans notre cas, on désire juste savoir s'il y a au moins un élément dans notre collection. C'est à cette question que l'opérateur Any répond. Il va parcourir notre collection et soit il ne trouvera aucun élément et renverra directement False, soit il va trouver le premier élément et s'arrêtera directement pour renvoyer True. En résumé, c'est comme si on se posait la question : Y a-t-il au moins un élément dans notre collection ?
Simple, n'est-ce pas ?!
Vous devez être identifié pour poster un commentaire.
15/05/09
11:58:32, Catégories: .NET, ASP.NET, Silverlight, Linq, Récapitulatif .NET, Récapitulatif Web, Récapitulatif, 83 mots 
, Jérôme Lambert [.NET][Web] LINQ, Silverlight 2, ASP.NET 3.5, téléchargez des E-Book Microsoft Press gratuitement !
Cette fois-ci, Microsoft a mis à disposition gratuitement une série de chapîtres de livres Microsoft Press autour de Visual Studio 2008. Au menu, du LINQ, Silverlight 2 et bien évidemment ASP.NET 3.5 !
|
|
|
|
- Chapitre 6 : Tools fo LINQ to SQL
- Chapitre 16 : LINQ and ASP.NET
Introducing Microsoft Silverlight 2
- Chapitre 1 : Introducing Silverlight 2
- Chapitre 2 : Using Expression blend with Silverlight 2
Programming Microsoft ASP.NET 3.5
- Chapitre 3 : Anatomy of an ASP.NET Page
- Chapitre 18 : HTTP Handlers and Modules
Pour les télécharger, c'est par ici.
Bonne lecture !
Vous devez être identifié pour poster un commentaire.
Blog de Jérôme Lambert
Je suis développeur et architecte junior autour des technologies Microsoft. Depuis 2010, j'ai l'honneur d'être reconnu MVP C# par Microsoft suite à mes contributions en ligne principalement sur Developpez.com. Vous pouvez me retrouver sur mon blog officiel : www.jeromelambert.net
Catégories
Rechercher
| Lun | Mar | Mer | Jeu | Ven | Sam | Dim |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | |||
| 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| 12 | 13 | 14 | 15 | 16 | 17 | 18 |
| 19 | 20 | 21 | 22 | 23 | 24 | 25 |
| 26 | 27 | 28 | 29 | 30 | 31 |
Divers
Syndiquez ce blog 
Articles :
Commentaires :
![[Valid RSS]](/img/valid-rss.png "Validate my RSS feed")
![[Valid Atom 1.0]](/img/valid-atom.png "Validate my Atom 1.0 feed")
phpmyvisites
Copyright © 2000-2012 - www.developpez.com