LINQ: Comment déclarer IEnumerable[AnonymousType]?

C'est ma fonction:

    private IEnumerable<string> SeachItem(int[] ItemIds)
    {
        using (var reader = File.OpenText(Application.StartupPath + @"\temp\A_A.tmp"))
        {
            var myLine = from line in ReadLines(reader)
                         where line.Length > 1
                         let id = int.Parse(line.Split('\t')[1])
                         where ItemIds.Contains(id)
                         let m = Regex.Match(line, @"^\d+\t(\d+)\t.+?\t(item\\[^\t]+\.ddj)")
                         where m.Success == true
                         select new { Text = line, ItemId = id, Path = m.Groups[2].Value };
            return myLine;
        }
    }

J'obtiens une erreur de compilation,car "myLine" n'est pas un IEnumerable[string] et je ne sais pas comment écrire IEnumerable[Anonyme]

"Impossible de convertir implicitement le type de Système.Les Collections.Génériques.IEnumerable[AnonymousType#1]' à 'Système.Les Collections.Génériques.IEnumerable[string]'"

InformationsquelleAutor Ivan Prodanov | 2009-05-23

.net c#linq

15

Vous ne pouvez pas déclarer IEnumerable<AnonymousType> parce que le type n'a pas (connue) de nom au moment de la construction. Donc, si vous voulez utiliser ce type dans une déclaration de fonction, d'en faire un type normal. Ou tout simplement modifier votre requête pour renvoyer un IENumerable<String> et le bâton avec ce type.

Ou de retour IEnumerable<KeyValuePair<Int32, String>> à l'aide de l'instruction select suivante.
```
select new KeyValuePair<Int32, String>(id, m.Groups[2].Value)
```
- Quand vous dites "select new {...}", vous avez fait une AnonymousType. Si sélectionner une chaîne, puis il devrait fonctionner.
- Non, mais vous pouvez revenir IEnumerable et l'utilisation de la CastByExample truc. Pas recommandé.
InformationsquelleAutor Daniel Brückner
9

La signature de la méthode sur SearchItem indique que la méthode renvoie un IEnumerable<string> mais l'anonyme de type déclaré dans votre requête LINQ n'est pas de type string. Si vous voulez garder la même signature de la méthode, vous devez modifier votre requête à sélectionner uniquement les strings. par exemple,
```
return myLine.Select(a => a.Text);
```
Si vous insistez sur le retour des données sélectionnées par votre requête, vous pouvez renvoyer une IEnumerable<object> si vous remplacez votre return déclaration avec
```
return myLine.Cast<object>();
```
Ensuite, vous pouvez consommer des objets à l'aide de la réflexion.

Mais vraiment, si vous allez à la consommation d'un type anonyme en dehors de la méthode qu'elle est déclarée, vous devez définir une classe d'un avoir de la méthode de retour d'un IEnumerable de cette classe. Les types anonymes sont la commodité, mais ils sont soumis à des abus.

InformationsquelleAutor jason
9

Je ne suis pas forcément recommander cet...
C'est une sorte de subversion du système de type, mais vous pouvez faire ceci:

1) changer votre signature de la méthode de retour IEnumerable (non générique)

2) ajouter un cast par exemple helper:
```
public static class Extensions{
    public static IEnumerable<T> CastByExample<T>(
            this IEnumerable sequence, 
            T example) where T: class
    {
        foreach (Object o in sequence)
            yield return o as T;
    }
}
```
3) puis d'appeler la méthode à quelque chose comme ceci:
```
var example = new { Text = "", ItemId = 0, Path = "" };
foreach (var x in SeachItem(ids).CastByExample(example))
{
    //now you can access the properties of x 
    Console.WriteLine("{0},{1},{2}", x.Text, x.ItemId, x.Path);
}
```
Et vous avez terminé.

La clé pour cela est le fait que si vous créez un type anonyme avec le même ordre, les types et les noms de propriété en deux lieux, les types qui peuvent être réutilisées. Sachant cela, vous pouvez utiliser des génériques pour éviter la réflexion.

Espérons que cette aide
Alex
- Intelligent. Mais vraiment, si quelqu'un va aller à ce que beaucoup de difficulté, il leur suffit d'encapsuler les données dans une déclaration de classe.
- Comme je l'ai dit je ne suis pas la recommande 😉
- ... il est intéressant de noter que vous allez seulement à ce problème une fois, c'est à dire une fois que vous avez l'aide de la méthode d'extension de ce système est facile à utiliser encore et encore. À la différence de roulement de nouveaux types de partout. De toute façon c'est un travail pour Tuple<T1,T2,T3> dans .NET 4.0
InformationsquelleAutor Alex James
6

Votre fonction est d'essayer de le retourner IEnumerable<string>, lorsque le LINQ relevé de compte que vous êtes en cours d'exécution est en fait le retour d'un IEnumerable<T> où T est une compilation de type généré. Les types anonymes ne sont pas toujours anonymes, car ils prennent spécifique, type de béton après le code est compilé.

Les types anonymes, cependant, car ils sont éphémères, jusqu'à ce compilé, ne peut être utilisé dans le champ d'application, ils sont créés dans. Pour répondre à vos besoins dans l'exemple que vous avez fournies, je dirais que la solution la plus simple est de créer une simple entité qui stocke les résultats de votre requête:
```
public class SearchItemResult
{
    public string Text { get; set; }
    public int ItemId { get; set; }
    public string Path { get; set; }
}

public IEnumerable<SearchItemResult> SearchItem(int[] itemIds)
{
    //...
    IEnumerable<SearchItemResult> results = from ... select new SearchItemResult { ... }
}
```
Toutefois, si votre but ultime n'est pas de récupérer un certain type d'objet, et vous êtes uniquement intéressé par, disons, le Chemin...alors vous pouvez toujours générer un IEnumerable<string>:
```
IEnumerable<string> lines = from ... select m.Groups[2].Value;
```
J'espère que ça aide à clarifier votre compréhension de LINQ, enumerables, et les types anonymes. 🙂
- Pour info: Il n'est pas rigoureusement exact de dire que les types anonymes sont uniques à la portée qu'ils ont créé. Les types anonymes qui sont structurellement équivalent dans la même assemblée, mais utilisé dans deux différentes méthodes sont en fait partagés entre ces méthodes. Il y a des astuces pour tirer profit de ce fait, mais je ne recommanderais pas; si vous avez besoin de partager un texte à travers deux méthodes, rendre nominale.
- C'est que Eric Lippert de Microsoft gloire? Maintenant que vous avez ouvert le sac, il faut laisser sortir le chat. Comment partagez-vous un type anonyme dans les étendues? 😉
- Très soigneusement. Vous devez utiliser dingo méthode d'inférence de type astuces et capturé extérieur variables. Je vais peut-être faire un blog sur un intervalle de temps.
- J'ai trouvé cette réponse très utile.
InformationsquelleAutor jrista
0

Une chose à retenir, c'est que LINQ consolidés exécution différée. Ce que cela signifie est que votre LINQ déclaration n'a pas fait exécuter jusqu'à ce que vous itérer sur elle dans un foreach déclaration ou que vous appelez la .ToList() méthode sur myLine.

Pour votre exemple, essayez de changer:
```
return myLine;
```
À:
```
return myLine.ToList();
```
- Le problème est dans la définition de la procédure,de sorte qu'il devrait être "private List<string> SeachItem(int[] ItemIds)" ,mais cela ne fonctionne pas non plus."Impossible de convertir implicitement le type de Liste[AnoynymousType#1], Liste[string].Merci de me dire si c'est juste impossible à faire. 🙂
InformationsquelleAutor Alexander Kahoun

Vous devez vous connecter pour publier un commentaire.