Regrouper par plusieurs colonnes dans les requêtes LINQ à l'aide de C#

1. Présentation de LINQ
2. Regrouper par plusieurs colonnes dans les requêtes LINQ à l’aide de C#

Cet article fournit une brève introduction aux requêtes LINQ utilisant C#. En outre, il explique comment regrouper les résultats par plusieurs colonnes à l’aide de requêtes LINQ.

Si vous êtes déjà familiarisé avec LINQ, vous pouvez ignorer en toute sécurité la section d’introduction.

Présentation de LINQ

LINQ, qui signifie Language Integrated Query, est une méthode qui nous fournit une méthode uniforme pour accéder aux données de différentes sources de données telles que des bases de données, des tableaux, XML, et bien plus encore. Il peut intégrer toutes les requêtes en lui-même.

Lorsque les développeurs développent une application, ils ont besoin de connaissances supplémentaires autres qu’un langage de programmation pour acquérir des données à partir de sources de données. Par exemple, si votre source de données est une base de données, un programmeur doit connaître SQL.

De même, le programmeur doit savoir comment analyser XML si la source de données est un document XML. Alors qu’avec LINQ, vous n’avez besoin que de connaissances sur LINQ pour acquérir des données à partir de toutes ces sources de données.

LINQ aux objets

LINQ to Objects signifie que vous pouvez utiliser des requêtes LINQ pour obtenir les données d’une structure de données en mémoire. Cette structure de données peut être définie par l’utilisateur ainsi que certaines API définies par DotNet.

La seule exigence pour la structure de données est qu’elle doit retourner la collection dans le type IEnummerable<T>.

Prenons un exemple de LINQ to Objects :

using System;
using System.Linq;

class MyProgram {
  static void Main() {
    string[] list = { "apple", "ball", "aeroplane", "beautiful", "ancient" };

    var starts = from w in list
                 where w.StartsWith("a") select w;
    // Print words
    foreach (var word in starts) {
      Console.WriteLine(word);
    }
  }
}

Production:

apple
aeroplane
ancient

Dans l’extrait de code ci-dessus, nous avons créé une requête LINQ pour accéder aux données à partir d’un tableau de chaînes. De cette manière, ce tableau peut être remplacé par n’importe quelle structure de données.

L’avantage de la requête LINQ est que sa syntaxe restera la même, que vous changiez la structure de données à l’arrière. La requête restera la même ; c’est l’uniformité fournie par LINQ.

LINQ vers SQL

Pour LINQ to ADO.Net, il existe 3 sous-composants. Mais, nous nous concentrerons principalement sur LINQ to SQL.

LINQ to SQL nous permet de convertir la base de données relationnelle en objets. Cela rend les opérations de données beaucoup plus simples et plus rapides.

Le processus suivi est qu’il se connecte d’abord à la base de données, convertit les requêtes LINQ en requêtes SQL, puis exécute ces requêtes SQL. Le résultat renvoyé par le SQL est reconverti en objets construits par LINQ, puis renvoyé à l’utilisateur.

LINQ trace également les modifications apportées aux données des objets et synchronise automatiquement ces modifications dans la base de données.

Lorsque vous créez un composant LINQ to SQL dans votre projet, il crée automatiquement les classes pour toutes les tables de base de données. Après cela, vous devez coder les opérations de connexion et de base de données.

Supposons que nous ayons une table pour stocker les données des employés d’une entreprise. Le nom de la table est Emp et contient les champs : Id, Name et Email.

Pour l’utiliser comme requêtes LINQ, considérez l’extrait de code suivant :

using System;
using System.Linq;

namespace MyLINQExample {
   class LINQExample {
      static void Main(string[] args) {

         string connectString = System.Configuration.ConfigurationManager.            ConnectionStrings["LinqToSQLDBConnectionString"].ToString();
         LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);
         Emp newEmp = new Emp();
         newEmp.name = "John";
         newEmp.email = "john@abccompany.com";
         newEmp.id = 3;
         //Add this new employee to the database
         db.Emps.InsertOnSubmit(newEmp);

         //To save changes in the database
         db.SubmitChanges();

         //Get the data of inserted employee
         Emp e = db.Emps.FirstOrDefault(e ⇒e.name.Equals("John"));

         Console.WriteLine("Emp Id = {0} , Name = {1}, Email = {2}",
                          e.id, e.name, e.email);

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Dans le code ci-dessus, nous nous sommes connectés à la base de données, avons créé un objet de contexte de données, puis avons exécuté notre requête sur la base de données.

Production:

Emp Id = 3, Name = John, Email = john@abccompany.com

Jointure dans LINQ

Comme les requêtes SQL simples, vous pouvez également joindre des colonnes à l’aide de requêtes LINQ. L’opération de jointure est effectuée lorsque vous avez besoin des données de différentes tables en fonction de certaines conditions.

LINQ fournit l’opérateur join qui peut facilement joindre une ou plusieurs colonnes. Considérons que nous avons les deux classes suivantes :

public class Student {
  public int Stu_ID { get; set; }
  public string Stu_Name { get; set; }
  public int Class_ID { get; set; }
}

public class Grade {
  public int Grade_ID { get; set; }
  public string Grade_Name { get; set; }
}

Dans la fonction driver, créons deux listes pour chaque classe comme suit :

IList<Student> students_list = new List<Student>() {
  new Student() { Stu_ID = 11, Stu_Name = "ABC", Class_ID = 1 },
  new Student() { Stu_ID = 12, Stu_Name = "DEF", Class_ID = 1 },
  new Student() { Stu_ID = 13, Stu_Name = "GHI", Class_ID = 2 },
  new Student() { Stu_ID = 14, Stu_Name = "JKL", Class_ID = 2 },
};

IList<Grade> gradeList = new List<Grade>() { new Grade() { Grade_ID = 1, Grade_Name = "Grade 1" },
                                             new Grade() { Grade_ID = 2, Grade_Name = "Grade 2" },
                                             new Grade() { Grade_ID = 3, Grade_Name = "Grade 3" } };

Maintenant, si nous souhaitons obtenir les noms des élèves et leurs grades, nous devons joindre ces deux tables. Ces tables seront jointes en fonction de Class_ID et Grade_ID, respectivement.

La requête de jointure ressemblera à ceci :

var joinResult =
    from s in student_list join g in gradeList on s.Class_ID equals g.Grade_ID select new {
      StuName = s.Stu_Name, GradeName = g.Grade_Name
    };

Cela donnera la sortie suivante :

ABC Grade 1
DEF Grade 1
GHI Grade 2
JKL Grade 2

Regrouper par plusieurs colonnes dans les requêtes LINQ à l’aide de C#

De la même manière, nous pouvons également regrouper les données en fonction d’un attribut. Ceci est fait en utilisant la clause GroupBy dans la requête LINQ.

L’opérateur GroupBy renvoie un sous-ensemble des éléments d’une collection fournie en fonction d’une valeur de clé. Les objets IGrouping<TKey, TElement> représentent chaque groupe.

De plus, la méthode GroupBy prend en charge différentes méthodes de surcharge afin que vous puissiez utiliser la méthode d’extension appropriée dans la syntaxe de la méthode en fonction de vos besoins.

Considérez le code suivant :

List<Student> student_List = new List<Student>() {
  new Student() { Stu_ID = 11, Stu_Name = "ABC", Age = 18, Subject = "Arts" },
  new Student() { Stu_ID = 12, Stu_Name = "DEF", Age = 19, Subject = "Science" },
  new Student() { Stu_ID = 13, Stu_Name = "GHI", Age = 18, Subject = "Arts" },
  new Student() { Stu_ID = 14, Stu_Name = "JKL", Age = 19, Subject = "Science" },
};

Supposons que nous voulions obtenir la liste des étudiants regroupés par âge. La requête suivante le fera pour nous :

var result = from s in student_List group s by s.Age;

foreach (var ageGroups in result) {
  Console.WriteLine("Age Group: {0}", ageGroups.Key);
  foreach (Student s in ageGroups)  // Each group has inner collection
    Console.WriteLine("Student Name: {0}", s.Stu_Name);
}

Production:

Age Group: 18
Student Name: ABC
Student Name: GHI
Age Group: 19
Student Name: DEF
Student Name: JKL

De même, nous pouvons également regrouper par plusieurs colonnes. Cela se fait de la manière suivante:

var result = from s in student_List group s by new { s.Age, s.Subject };
foreach (var ageGroups in groupedResult) {
  Console.WriteLine("Group: {0}", ageGroups.Key);

  foreach (Student s in ageGroups)  // Each group has inner collection
    Console.WriteLine("Student Name: {0}", s.Stu_Name);
}

Cette requête donnera le résultat suivant :

Group: {Age= 18, Subject="Arts"}
Student Name: ABC
Student Name: GHI
Group: {Age= 19, Subject="Science"}
Student Name: DEF
Student Name: JKL