Groupe 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 du même PersonIDs, 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"    };

Est-il une manière que je peux groupe par personID et 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 regroupement, je voudrais obtenir:

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

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

De 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 svp me pointer dans la bonne direction?

dans l'esprit de pedanticism, une adresse est à peu près autant d'une propriété intrinsèque de la personne de leur voiture. aussi, on ne serait sans doute de stocker leur date de naissance plutôt que de l'âge.
Il est un autre exemple dont Count et Sum ici stackoverflow.com/questions/3414080/...
Källman: je suis d'accord avec Chris Walsh. Les plus susceptibles d'une application qui a l'O. P. "Personne(s)" de la Classe (Table) auraient déjà un ""normal "" "Personne(s)" de la Classe (Tableau) qui a l'usu. Propriétés / Colonnes (nom, sexe, date de naissance). L'O. P. "Personne(s)" de la Classe (Table) serait pro être un Enfant de la Classe (Tableau) de la ""normal "" "Personne(s)" de la Classe ( Tableau) (c'est à dire un "OrderItem(s)" de la Classe (Tableau) par rapport à une "Commande(s)" de la Classe (Tableau)). L'O. P. a probablement pas utiliser le nom qu'il avait utiliser si elle était dans le même Champ d'application que son ""normal "" "Personne(s)" de la Classe (Tableau) et/ou peuvent l'ai simplifié pour ce post.

InformationsquelleAutor test123 | 2011-09-06

c#group-by linq

1591

Absolument - en gros, vous voulez:
```
var results = from p in persons
              group p.car by p.PersonId into g
              select new { PersonId = g.Key, Cars = g.ToList() };
```
Ou de la non-expression de 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 (lors de l'afficher comme un IEnumerable<T>) est une séquence de quelles que soient les valeurs étaient dans la projection (p.car dans ce cas) présents pour la clé donnée.

Pour en savoir plus sur la façon dont GroupBy œuvres, voir mon Edulinq post sur le sujet.

(Je l'ai renommé PersonID à PersonId ci-dessus, à suivre .NET des conventions de nommage.)

Sinon, vous pouvez utiliser un Lookup:
```
var carsByPersonId = persons.ToLookup(p => p.PersonId, p => p.car);
```
Vous pouvez ensuite 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];
```
- Skeet ce que si je veux ajouter un autre bien comme nom
- Ensuite, vous indiquez-le dans le type anonyme.
- voici une bonne explication de groupe, il comprend également un exemple de regroupement par une clé composite: Comment: Groupe de Résultats d'une Requête (Guide de Programmation C#)
- vous pouvez faire quelque chose comme .GroupBy(p => new {p.Id, p.Name}, p => p, (key, g) => new { PersonId = key.Id, PersonName = key.Name, PersonCount = g.Count()}) et vous obtiendrez toutes les personnes qui se produisent avec un Id, Nom, et un certain nombre d'occurrences pour chaque personne.
- Il devrait être PersonID au lieu de PersonId.
- J'ai été délibérément suivantes .NET des conventions de nommage, la fixation de l'OP noms, en fait. Va le dire clairement dans la réponse.
- au lieu de var, vous devez mettre le type réel de résultats, pour être encore plus clair sur ce que ce n'/crée.
- Skeet: Nice. Cependant, (et cela peut une nouvelle Q), j'étais effectivement en train de créer (pour utiliser des termes équivalents pour des OP de domaine) SortedDictionary <PersonIdInt, SortedDictionary <CarNameString, CarInfoClass>>. Le plus proche que je pouvais obtenir de l'aide de LINQ a été IEnumerable <IGrouping <PersonIdInt, Dictionary <CarNameString, PersonIdCarNameXrefClass>>>. J'ai fini à l'aide de @akazemis de for(each) méthode de boucle qui, d'ailleurs, était 2x plus vite (et bien sûr, plus facile à déboguer).
- Oui, cela sonne comme une nouvelle question, et qui ne sonne pas comme un facile-à-comprendre la suite par tous les moyens. J'ai ajouté la possibilité d'utiliser un Lookup pour cette réponse, qui, je pense, serait l'approche la plus simple...
- Skeet: (Encore une fois, je suis exprimant dans des OP de domaine en termes de sorte qu'il peut ne pas être une utilisation pratique dans son domaine:) j'ai un multi-élément, sélectionnez-en mesure de zone de liste déroulante de PersonId est que lorsque chaque élément est activée/désactivée, re-par défaut (pas de ré-s'appuie), les Voitures dans un multi-élément, sélectionnez-en mesure de zone de liste déroulante de Voitures. Donc, je dois utiliser une structure (w/o, nettement plus de la mémoire / de codage) permet à la plupart des recherches des deux PersonId est ainsi que CarNames est dans la liste des CarsNames pour que PersonId. MSDN ne montre pas un O pour Lookup Propriétés. SortedDictionary sont O(log n).
- Je ne vois pas de preuves que c' est l'OP du domaine - ou au moins, pas le problème qu'ils essaient de résoudre. (En particulier, ils n'expriment pas besoin de faire des recherches par nom de voiture.) Mais je m'attends à une Lookup avoir O(1) l'accès, comme je l'avais espérer qu'il soit basé sur une Dictionary<,> ou similaire. Voir codeblog.jonskeet.royaume-uni/2010/12/31/... pour plus de détails.
- Skeet: 1) LOL! Ok, vous êtes en train de lire trop dans le "domaine". Je suis juste d'assimiler mon "domaine"de l'conditions pour sa ne pas, de tout mon "domaine"de l'problème (c'est à dire sa PersonId sont mes DeptId et sa Voiture(Nom)'s sont mes UserGroupId dans la mesure où les 2 derniers sont ses/mes articles étant regroupées et les anciens sont son/mon Groupe de Clés). Je ne dis pas qu'il essaie de re-par défaut des zones de liste modifiable ou même faire une recherche d'un CarName à l'intérieur d'une Personne CarNames. Comme je l'ai dit, cela "pourrait doit être un nouveau Q". ...
- Skeet: 2), Même si Lookup O(1) (et je ne vois pas comment il pourrait l'être, sauf si la Clé se trouve être un entier de Type et se trouve être ascendante par rapport à la commande d'insertion et séparés par le même incrément (aucun (sauf pour le Type) par la / spécifié à Lookup), ce qui pourrait être formulaicly résolu dans un Index de Tableau en supposant que c'est même stocké dans un Tableau), il semble que l'utilisation de il permettrait seulement efficace look-ups d'un PersonId vs aussi un CarName après récupération de PersonId de CarNames.
- Désolé, vous avez perdu moi en termes de faire différents types de recherche. Que a rien à voir avec cette question. Il semble certainement comme vous devriez vous poser une nouvelle question. Quant à la façon dont les recherches peuvent être O(1) (au moins dans le cas le plus courant; absolu pire des cas O(n) si tout a le même code de hachage): look up tables de hachage...
- Si vous voulez de groupe par PersonId, mais vous aurez toujours besoin d'accéder à d'autres propriétés de Person?
- Alors il faudrait juste changer p.car à p dans l'exemple de mon code, et que vous souhaitez jusqu'à la fin avec des groupes de Person éléments.
- hey Jon, ont-ils modifier les docs sur vous? la doc est lié indique maintenant: "Un cas particulier est fait pour les deux lettres sigles dans lequel les deux lettres sont en majuscule, comme montré dans l'identifiant suivant: IOStream" PersonID correspondent à cette catégorie ne serait-il pas?
- Non, parce que les "Id" est une abréviation, n'est pas un acronyme. Il est appelé dans le tableau "en Profitant des Mots Composés et des Termes Communs" - Id et id, pas d'identité.
InformationsquelleAutor Jon Skeet

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()/**/}

InformationsquelleAutor Tallat

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

InformationsquelleAutor Yogendra Paudyal

Vous pouvez également Essayer cette.

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

InformationsquelleAutor shuvo sarker

essayer

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

pour vérifier si une personne est de répéter dans votre liste d'essayer

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

InformationsquelleAutor Code First

J'ai créé un exemple de code avec la Syntaxe de la Requête et de la Méthode de la Syntaxe. J'espère que cela aide les autres 🙂

Vous pouvez également exécuter le code sur .Net Violon 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

InformationsquelleAutor Recev Yildiz

2

Essayez ceci :
```
var results= persons.GroupBy(n => n.PersonId)
.Select(g => new {
PersonId=g.Key,
Cars=g.Select(p=>p.car).ToList())}).ToList();
```
Mais en terme de performance suivantes pratique est mieux et plus optimisé l'utilisation de la mémoire (lors de 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];
```
- g.Key.PersonId? g.SelectMany?? De toute évidence, vous n'essayez pas de le faire.
- vous êtes à l'écrire, j'ai corrigé certains codes de codes et de ne pas le tester. Mon point principal était la deuxième partie. Mais de toute façon merci pour votre attention. Il était trop tard pour modifier ce code lorsque j'ai réalisé que c'est faux. donc g.Clé remplace g.Clé.PersonId, et de Sélectionner plutôt que SelectMany ! tellement bordélique désolé :)))
- J'étais en fait en train de créer (pour utiliser des termes équivalents pour des OP de domaine) SortedDictionary <PersonIdInt, SortedDictionary <CarNameString, CarInfoClass>>. Le plus proche que je pouvais obtenir de l'aide de LINQ a été IEnumerable <IGrouping <PersonIdInt, Dictionary <CarNameString, PersonIdCarNameXrefClass>>>. J'ai fini à l'aide de votre for méthode de boucle qui, d'ailleurs, était 2x plus rapide. Aussi, je voudrais utiliser: a) foreach vs for et b) TryGetValue vs ContainsKey (SÈCHES principe - dans le code & runtime).
InformationsquelleAutor akazemis

Une autre façon de faire pourrait être select distinct PersonId et du groupe de la jointure avec le 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 même avec l'API fluent syntaxe:

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 PersonId dans notre cas), chacun avec un groupe d'entrées jointes dans la deuxième liste (liste de persons).

InformationsquelleAutor Dmitry Stepanov

-1

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

InformationsquelleAutor user3474287

Vous devez vous connecter pour publier un commentaire.