impossible de convertir implicitement le type quand groupby

J'obtiens cette erreur quand j'essaie de groupe par CellID:

Impossible de convertir implicitement le type de Système.Les Collections.Génériques.Liste
Système.Linq.IGrouping int,p2pControllerLogAnalyser.Modèles.GSMData' à
'Système.Les Collections.Génériques.Liste
p2pControllerLogAnalyser.Modèles.GSMData'

public List<GSMData> GetCellID()
{
    return Gsmdata.GroupBy(x => x.CellID).ToList();
}

Ce que je fais mal et comment puis-je résoudre ce problème?

GroupBy retourne un IEnumerable<IGrouping<TKey, TElement>>, de sorte qu'il ne peut pas être traduit à List<TElement> de la manière que vous faites. Pourquoi êtes-vous de regroupement du tout? Pourquoi ne pas OrderBy à la place? Regroupement et ensuite d'essayer de les aplatir une liste est soit involontaire ou b) d'imiter la commande de la sémantique.
ce qu'attend la sortie?
Je veux montrer une liste de CellID et combien de Mètres sont à l'aide de chaque CellID. Le Regroupement de la partie est, car il y a plusieurs entrées avec le même CellID et je ne veux pas de doublons
Donc, vous voulez cellules distinctes Id?

InformationsquelleAutor user3240428 | 2014-02-21

c#linq

6

Si vous avez vraiment besoin de faire cela, si je ne peux pas imaginer pourquoi, vous devez aplatir le groupe par groupe enumerables en une seule liste à l'aide de SelectMany:
```
public List<GSMData> GetCellID()
{
    return Gsmdata
        .GroupBy(x => x.CellID)
        .SelectMany(gr => gr)
        .ToList();
}
```
Bien sûr, il semble que vous essayez de lot les éléments avec le même CellID ensemble, de sorte que vous pouvez simplement commander:
```
public List<GSMData> GetCellID()
{
    return Gsmdata
        .OrderBy(x => x.CellID)
        .ToList();
}
```
Suite à vos commentaires, distinctes CellID valeurs peuvent être retournés ainsi:
```
return Gsmdata.Select(x => x.CellID).Distinct();
```
Si vous souhaitez retourner un IDENTIFIANT et d'un nombre de données groupées, vous pouvez regrouper en un type anonyme:
```
return Gsmdata
    .GroupBy(x => x.CellID)
    .Select(gr => new { CellID = gr.Key, Count = gr.Count() });
```
Mais si vous êtes de retour ce à partir d'une méthode que je ferais un détectable type et ne pas utiliser un type anonyme.

InformationsquelleAutor Adam Houldsworth
0

Le problème est que GroupBy renvoie une collection groupée, dans ce cas System.Collections.Generic.List<System.Linq.IGrouping<int, p2pControllerLogAnalyser.Models.GSMData>>. Votre méthode retourne un List<GSMData>.

Afin de résoudre ce problème, vous devez ajuster votre déclaration de méthode et/ou de votre requête Linq de sorte que les types de match.

De vos commentaires, je comprends que vous voulez retourner une liste des cellules distinctes id. Vous pouvez le faire en modifiant à la fois la déclaration de la méthode et de la requête Linq (je suis en supposant que CellID est de type int, basé sur le type dans le IGrouping):
```
public List<int> GetCellID()
{
    return Gsmdata.Select(x => x.CellID)
                  .Distinct().ToList();
}
```
InformationsquelleAutor Markus

si je comprends droite, vous besoin de quelque chose comme ce

var result = (from gdata in Gsmdata
              group gdata by gbata.CellID into g
              select new Result{
                  CellID = g.Key,
                  Meters = g.Sum(i=>i.Meter)
              }
             ).ToList();

où Result est

public class Result{
    public /*type your CellID */ CellID;
    public /*type your Meter */  Meters;
}

InformationsquelleAutor Grundy

Vous devez vous connecter pour publier un commentaire.