Langage C# – LINQ est indispensable !

En 2008, Microsoft a proposé une révolution dans la manière d’écrire les traitements de données avec l’apparition au sein du langage C# et du Framework .NET d’instructions et composants de requêtage. D’un point de vue syntaxique, Microsoft propose plusieurs manières de requêter une source de données :

  1. Soit un utilisant uniquement les méthodes d’extension étendant l’interface IEnumerable du Framework .NET (implémentée par la très grande majorité des collections du Framework .NET) et les expressions lambda
  2. Soit en utilisant les instructions LINQ (Language Integrated Query) du langage C#
  3. Soit en mixant les deux

En voici une première illustration :
Linq

Voici une simple démonstration mettant en relief cette révolution. A partir de la liste de chaînes de caractères présentées ci-dessous :

// Filtrage
List<string> oListeLibellesFormations;
oListeLibellesFormations = new List<string>();
foreach (string s in this.ListeLibellesFormations)
{
    if (s.Length >= 5)
    {
        oListeLibellesFormations.Add(s);
    }
}
this.ListeLibellesFormations = oListeLibellesFormations;

// Suppression des doublons
List<string> oListeLibellesFormations;
oListeLibellesFormations = new List<string>();
foreach (string s in this.ListeLibellesFormations)
{
    if (!oListeLibellesFormations.Contains(s))
    {
        oListeLibellesFormations.Add(s);
    }
}
this.ListeLibellesFormations = oListeLibellesFormations;

// Tri
List<string> oListeLibellesFormations;
int i;
oListeLibellesFormations = new List<string>();
foreach (string s in this.ListeLibellesFormations)
{
    i = 0;
    while (i < oListeLibellesFormations.Count)
    {
        if (string.Compare(s, oListeLibellesFormations[i], true) < 0)
        {
            oListeLibellesFormations.Insert(i, s);
            break;
        }
        i++;
    }
    if (i == oListeLibellesFormations.Count)
    {
        oListeLibellesFormations.Add(s);
    }
}
this.ListeLibellesFormations = oListeLibellesFormations;


// On passe les 2 premiers éléments de la liste
if (this.ListeLibellesFormations.Count > 0)
{
    this.ListeLibellesFormations.RemoveAt(0);
}

if (this.ListeLibellesFormations.Count > 0)
{
    this.ListeLibellesFormations.RemoveAt(0);
}


// On Obtient les 2 premiers éléments de la liste
List<string> oListeLibellesFormations = new List<string>();
if (this.ListeLibellesFormations.Count > 2)
{
    oListeLibellesFormations.Add(this.ListeLibellesFormations[0]);
    oListeLibellesFormations.Add(this.ListeLibellesFormations[1]);
}
else
{
    oListeLibellesFormations = this.ListeLibellesFormations;
}
this.ListeLibellesFormations = oListeLibellesFormations;

Qu’est-ce que Linq a pu apporter ? Grâce à Linq, l’ensemble du code écrit ci-dessus peut être remplacé par le bloc de code suivant :

List<string> oListe = oListeLibellesFormations
    .Where(o => o.Length >= 5)  // Filtrage
    .Distinct()                 // Suppression des doublons
    .OrderBy(o => o)            // Tri
    .Skip(2)                    // On passe les 2 premiers éléments de la liste
    .Take(2)                    // On Obtient les 2 premiers éléments de la liste
    .ToList();

Ou

List<string> oListe = (from s in this.ListeLibellesFormations
                       where s.Length >= 5
                       orderby s
                       select s).Distinct()
                                .Skip(2)
                                .Take(2)
                                .ToList();

Avec Linq, le code est plus simple à écrire, plus facile à mettre au point et plus facile à maintenir. Certes, il est nécessaire de passer un peu de temps pour se familiariser avec les expressions lambda et méthodes d’extension du Framework .NET, étendant l’interface générique IEnumerable. Voici une première liste (importer l’espace de nom System.Linq pour les utiliser) :

All : Permet de vérifier que tous les éléments d’une liste satisfont une condition

Any : Permet de vérifier qu’au moins un élément d’une liste satisfait une condition

Average : Permet de calculer la moyenne d’une liste de données numériques

Cast : Permet de convertir les éléments d’une liste en un type donné

Concat : Permet de concaténer deux listes d’éléments

Contains : Permet de vérifier qu’une liste contient un élément

Count : Permet de connaître le nombre d’éléments dans une liste

DefaultIfEmpty : Renvoie une liste si elle n’est pas vide. Si elle est vide, une valeur par défaut précisée en paramètre est renvoyée

Distinct : Permet d’obtenir une séquence sans doublon

ElementAt : Permet d’obtenir le nième élément d’une séquence (indice de base 0)

Except : Permet d’extraire d’une liste, les éléments non présents dans une seconde liste

First : Permet d’obtenir le premier élément d’une liste, qui ne doit pas être vide

FirstOrDefault : Permet d’obtenir le premier élément d’une liste. Si elle est vide, la valeur par défaut du type est renvoyée

GroupBy : Permet de regrouper une liste d’éléments suivant une clé Intersect Permet de réaliser une intersection de deux listes d’éléments

LongCount : Permet d’obtenir un nombre d’élément (de type Long)

Max : Permet d’obtenir une valeur/un objet qui a la plus grande valeur

Min : Permet d’obtenir une valeur/un objet qui a la plus petite valeur

OfType : Permet d’obtenir les éléments d’une liste qui sont d’un type donné

OrderBy : Permet de trier les éléments d’une liste, dans l’ordre croissant, suivant une clé de tri

Reverse : Permet d’inverser l’ordre des éléments d’une liste

Skip : Permet d’obtenir les éléments d’une liste, à partir d’un indice donné

Sum : Permet de calculer la somme d’une liste de données numériques

Take : Permet d’obtenir les n premiers éléments d’une liste

ToList : Permet d’obtenir une liste d’éléments

Union : Permet de réaliser une union de deux listes d’éléments

Where : Permet d’obtenir d’une liste d’éléments respectant une condition

About: James RAVAILLE

Travaillant avec la plateforme Microsoft .NET depuis 2002, j’alterne les missions de formation et d’ingénierie avec cette plateforme. J’écris ce blog pour transmettre mes connaissances à tout développeur, qu’il soit débutant ou expérimenté.