Linq sélectionnez à nouveau l'objet

J'ai une requête linq

var x = (from t in types select t).GroupBy(g =>g.Type)

les groupes d'objets par leur type, comme un résultat que je souhaite à avoir un seul nouvel objet contenant tous les objets groupés et leur nombre. Quelque chose comme ceci:

type1, 30    
type2, 43    
type3, 72

pour être plus clair: le regroupement des résultats devrait être un objet n'est pas un objet par type d'élément

InformationsquelleAutor Jeff | 2012-05-25

c#group-by linq

Lire : 101 LINQ Échantillons dans ce LINQ - le Groupement d'Opérateurs à partir de Microsoft MSDN site

var x = from t in types  group t by t.Type
         into grp    
         select new { type = grp.key, count = grp.Count() };

forsingle objet utiliser stringbuilder et d'ajouter que va faire ou à convertir ce en forme de dictionnaire

    //fordictionary 
  var x = (from t in types  group t by t.Type
     into grp    
     select new { type = grp.key, count = grp.Count() })
   .ToDictionary( t => t.type, t => t.count); 

   //for stringbuilder not sure for this 
  var x = from t in types  group t by t.Type
         into grp    
         select new { type = grp.key, count = grp.Count() };
  StringBuilder MyStringBuilder = new StringBuilder();

  foreach (var res in x)
  {
       //: is separator between to object
       MyStringBuilder.Append(result.Type +" , "+ result.Count + " : ");
  }
  Console.WriteLine(MyStringBuilder.ToString());

Merci, c'est assez bon pour moi

InformationsquelleAutor Pranay Rana

28

Tous les regroupées objets, ou tous les types? On dirait que vous voulez juste:
```
var query = types.GroupBy(t => t.Type)
                 .Select(g => new { Type = g.Key, Count = g.Count() });

foreach (var result in query)
{
    Console.WriteLine("{0}, {1}", result.Type, result.Count);
}
```
EDIT: Si vous voulez dans un dictionnaire, vous pouvez simplement utiliser:
```
var query = types.GroupBy(t => t.Type)
                 .ToDictionary(g => g.Key, g => g.Count());
```
Il n'y a pas besoin de sélectionner en paires et puis construire le dictionnaire.
- Désolé pour les non question claire. Votre solution est très similaire à ce dont j'ai besoin, mais je veux avoir toutes regroupement des résultats dans un seul objet, non pas d'un objet par type
- La réponse que vous avez accepté, c'est effectivement la même que la mienne... juste dans un dictionnaire. Les résultats est tous dans un seul objet (query). Il n'est pas encore clair ce que vous voulez réaliser que ma solution n'est pas faire pour vous. Si vous allez à un groupe par type, vous avez eu pour avoir un objet par groupe, mais ici query est la requête qui permet de donner vous tous ces groupes.
- Eh bien, je sais quels types je vais être à la recherche d'une liste regroupant, afin de l'avoir dans le dictionnaire semble être assez facile de créer un objet à l'extérieur de la requête
- Afin de vous ne vous voulez un dictionnaire? (Il n'est pas encore très clair...) Si vous voulez un dictionnaire, c'est très bien - voir mon edit pour un peu plus simple façon de construire le dictionnaire de la accepté de répondre.
- C'est un peu différent de ce à quoi je m'attendais, mais depuis que je peux l'avoir à ce dictionnaire, il est assez bon pour résoudre mon problème. Merci beaucoup pour l'aide
InformationsquelleAutor Jon Skeet

Les réponses ici m'a fait fermer, mais en 2016, j'ai été capable d'écrire la suite de LINQ:

List<ObjectType> objectList = similarTypeList.Select(o =>
    new ObjectType
    {
        PropertyOne = o.PropertyOne,
        PropertyTwo = o.PropertyTwo,
        PropertyThree = o.PropertyThree
    }).ToList();

c'est cool et instructif! merci!

InformationsquelleAutor dckuehn

3
```
var x = from t in types
        group t by t.Type into grouped
        select new { type = grouped.Key,
                     count = grouped.Count() };
```
- côté question: en général, si vous faites un select new {..} est-il insérer quelque chose dans la base de données lorsque vous updateChanges ?
- vous n'avez pas besoin d'appeler updateChanges lorsque vous utilisez les instructions select. Si vous utilisez, il ne sera pas insérer quoi que ce soit, il suffit d'exécuter une instruction select dans la base de données.
InformationsquelleAutor daryal

Si vous voulez être en mesure d'effectuer une recherche sur chaque type pour obtenir sa fréquence, alors vous aurez besoin pour transformer l'énumération dans un dictionnaire.

var types = new[] {typeof(string), typeof(string), typeof(int)};
var x = types
        .GroupBy(type => type)
        .ToDictionary(g => g.Key, g => g.Count());
foreach (var kvp in x) {
    Console.WriteLine("Type {0}, Count {1}", kvp.Key, kvp.Value);
}
Console.WriteLine("string has a count of {0}", x[typeof(string)]);

InformationsquelleAutor Steve

0

C'est un grand article pour la syntaxe nécessaire pour créer de nouveaux objets à partir d'une requête LINQ.

Mais, si les missions à remplir dans les champs de l'objet sont rien de plus que des tâches simples, par exemple, l'analyse de chaînes de nombres entiers, et l'un d'eux tombe en panne, il n'est pas possible de débogage. Vous ne pouvez pas créer un point d'arrêt sur l'un des affectations individuelles.

Et si vous vous déplacez tous les devoirs, à une sous-routine, et de renvoyer un nouvel objet à partir de là, et tenter de définir un point d'arrêt dans cette routine, vous pouvez définir un point d'arrêt dans cette routine, mais le point d'arrêt ne sera jamais déclenché.

Ainsi, au lieu de:
```
var query2 = from c in doc.Descendants("SuggestionItem")
                select new SuggestionItem
                       { Phrase = c.Element("Phrase").Value
                         Blocked = bool.Parse(c.Element("Blocked").Value),
                         SeenCount = int.Parse(c.Element("SeenCount").Value)
                       };
```
Ou
```
var query2 = from c in doc.Descendants("SuggestionItem")
                         select new SuggestionItem(c);
```
J'ai plutôt fait:
```
List<SuggestionItem> retList = new List<SuggestionItem>();

var query = from c in doc.Descendants("SuggestionItem") select c;

foreach (XElement item in query)
{
    SuggestionItem anItem = new SuggestionItem(item);
    retList.Add(anItem);
}
```
Cela m'a permis de résoudre facilement et de comprendre assignation qui a été un échec. Dans ce cas, le XElement manquait un domaine que j'était d'analyse pour définir dans le SuggestionItem.

J'ai couru dans ces pièges avec Visual Studio en 2017, lors de l'écriture de tests unitaires pour une nouvelle routine de bibliothèque.

InformationsquelleAutor Garnet R. Chaney

Vous devez vous connecter pour publier un commentaire.