Grouper par dans LINQ

Supposons que si nous avons une classe comme:

class Person { 
    internal int PersonID; 
    internal string car; 
}

Maintenant, j'ai une liste de cette classe: List<Person> persons;

Maintenant, cette liste peut avoir plusieurs instances avec les mêmes PersonID, par exemple:

persons[0] = new Person { PersonID = 1, car = "Ferrari" }; 
persons[1] = new Person { PersonID = 1, car = "BMW"     }; 
persons[2] = new Person { PersonID = 2, car = "Audi"    }; 

Existe-t-il un moyen de me regrouper PersonIDet d'obtenir la liste de toutes les voitures qu'il a?

Par exemple, le résultat attendu serait

class Result { 
   int PersonID;
   List<string> cars; 
}

Donc après le regroupement, j'obtiendrais:

results[0].PersonID = 1; 
List<string> cars = results[0].cars; 

result[1].PersonID = 2; 
List<string> cars = result[1].cars;

D'après ce que j'ai fait jusqu'à présent:

var results = from p in persons
              group p by p.PersonID into g
              select new { PersonID = g.Key, // this is where I am not sure what to do

Quelqu'un pourrait-il m'orienter dans la bonne direction?

Absolument - vous voulez essentiellement:

var results = from p in persons
              group p.car by p.PersonId into g
              select new { PersonId = g.Key, Cars = g.ToList() };

Ou en tant qu'expression sans requête:

var results = persons.GroupBy(
    p => p.PersonId, 
    p => p.car,
    (key, g) => new { PersonId = key, Cars = g.ToList() });

Fondamentalement, le contenu du groupe (lorsqu'il est considéré comme un IEnumerable<T>) est une séquence de toutes les valeurs présentes dans la projection ( p.cardans ce cas) présente pour la clé donnée.

Pour en savoir plus sur le GroupByfonctionnement, consultez mon article Edulinq sur le sujet .

(Je l' ai retitré PersonIDà PersonIddans ce qui précède, de suivre les conventions de nommage .NET .)

Alternativement, vous pouvez utiliser Lookup:

var carsByPersonId = persons.ToLookup(p => p.PersonId, p => p.car);

Vous pouvez alors obtenir les voitures pour chaque personne très facilement:

// This will be an empty sequence for any personId not in the lookup
var carsForPerson = carsByPersonId[personId];

var results = from p in persons
              group p by p.PersonID into g
              select new { PersonID = g.Key,
                           /**/car = g.Select(g=>g.car).FirstOrDefault()/**/}

var results = from p in persons
              group p by p.PersonID into g
              select new { PersonID = g.Key, Cars = g.Select(m => m.car) };

Vous pouvez également essayer ceci:

var results= persons.GroupBy(n => new { n.PersonId, n.car})
                .Select(g => new {
                               g.Key.PersonId,
                               g.Key.car)}).ToList();

essayer

persons.GroupBy(x => x.PersonId).Select(x => x)

ou

pour vérifier si une personne se répète dans votre liste, essayez

persons.GroupBy(x => x.PersonId).Where(x => x.Count() > 1).Any(x => x)

J'ai créé un exemple de code de travail avec la syntaxe de requête et la syntaxe de méthode. J'espère que ça aide les autres :)

Vous pouvez également exécuter le code sur .Net Fiddle ici:

using System;
using System.Linq;
using System.Collections.Generic;

class Person
{ 
    public int PersonId; 
    public string car  ; 
}

class Result
{ 
   public int PersonId;
   public List<string> Cars; 
}

public class Program
{
    public static void Main()
    {
        List<Person> persons = new List<Person>()
        {
            new Person { PersonId = 1, car = "Ferrari" },
            new Person { PersonId = 1, car = "BMW" },
            new Person { PersonId = 2, car = "Audi"}
        };

        //With Query Syntax

        List<Result> results1 = (
            from p in persons
            group p by p.PersonId into g
            select new Result()
                {
                    PersonId = g.Key, 
                    Cars = g.Select(c => c.car).ToList()
                }
            ).ToList();

        foreach (Result item in results1)
        {
            Console.WriteLine(item.PersonId);
            foreach(string car in item.Cars)
            {
                Console.WriteLine(car);
            }
        }

        Console.WriteLine("-----------");

        //Method Syntax

        List<Result> results2 = persons
            .GroupBy(p => p.PersonId, 
                     (k, c) => new Result()
                             {
                                 PersonId = k,
                                 Cars = c.Select(cs => cs.car).ToList()
                             }
                    ).ToList();

        foreach (Result item in results2)
        {
            Console.WriteLine(item.PersonId);
            foreach(string car in item.Cars)
            {
                Console.WriteLine(car);
            }
        }
    }
}

Voici le résultat:

1
Ferrari
BMW
2
Audi
-----------
1
Ferrari
BMW
2
Audi

Essaye ça :

var results= persons.GroupBy(n => n.PersonId)
            .Select(g => new {
                           PersonId=g.Key,
                           Cars=g.Select(p=>p.car).ToList())}).ToList();

Mais en termes de performances, la pratique suivante est meilleure et plus optimisée dans l'utilisation de la mémoire (lorsque notre tableau contient beaucoup plus d'éléments comme des millions):

var carDic=new Dictionary<int,List<string>>();
for(int i=0;i<persons.length;i++)
{
   var person=persons[i];
   if(carDic.ContainsKey(person.PersonId))
   {
        carDic[person.PersonId].Add(person.car);
   }
   else
   {
        carDic[person.PersonId]=new List<string>(){person.car};
   }
}
//returns the list of cars for PersonId 1
var carList=carDic[1];

Une autre façon de procéder pourrait être de sélectionner un PersonIdgroupe distinct et de se joindre à persons:

var result = 
    from id in persons.Select(x => x.PersonId).Distinct()
    join p2 in persons on id equals p2.PersonId into gr // apply group join here
    select new 
    {
        PersonId = id,
        Cars = gr.Select(x => x.Car).ToList(),
    };

Ou la même chose avec une syntaxe API fluide:

var result = persons.Select(x => x.PersonId).Distinct()
    .GroupJoin(persons, id => id, p => p.PersonId, (id, gr) => new
    {
        PersonId = id,
        Cars = gr.Select(x => x.Car).ToList(),
    });

GroupJoin produit une liste d'entrées dans la première liste (liste de PersonIddans notre cas), chacune avec un groupe d'entrées jointes dans la deuxième liste (liste de persons).

L'exemple suivant utilise la méthode GroupBy pour renvoyer des objets regroupés par PersonID.

var results = persons.GroupBy(x => x.PersonID)
              .Select(x => (PersonID: x.Key, Cars: x.Select(p => p.car).ToList())
              ).ToList();

Ou

 var results = persons.GroupBy(
               person => person.PersonID,
               (key, groupPerson) => (PersonID: key, Cars: groupPerson.Select(x => x.car).ToList()));

Ou

 var results = from person in persons
               group person by person.PersonID into groupPerson
               select (PersonID: groupPerson.Key, Cars: groupPerson.Select(x => x.car).ToList());

Ou vous pouvez utiliser ToLookup, ToLookuputilise essentiellement EqualityComparer<TKey>.Default pour comparer les clés et faire ce que vous devez faire manuellement lorsque vous utilisez le regroupement par et dans le dictionnaire. je pense que c'est inmemory excuted

 ILookup<int, string> results = persons.ToLookup(
            person => person.PersonID,
            person => person.car);

Tout d'abord, définissez votre champ clé. Incluez ensuite vos autres champs:

var results = 
    persons
    .GroupBy(n => n.PersonId)
    .Select(r => new Result {PersonID = r.Key, Cars = r.ToList() })
    .ToList()