LINQ: Wie IEnumerable [AnonymousType] deklarieren?

Question

Dies ist meine Funktion:

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; 
     } 
    } 

ich einen Compiler-Fehler erhalten, weil "Myline" kein IEnumerable [string] ist, und ich weiß nicht, wie IEnumerable [Anonymous]

„Kann nicht schreiben implizit Typ 'System.Collections.Generic.IEnumerable [AnonymousType # 1]' auf 'System.Collections.Generic.IEnumerable [string]“

Answer 1

Sie nicht IEnumerable<AnonymousType> erklären kann, weil der Typ keine (bekannten) Namen zum Zeitpunkt der Erstellung hat. Wenn Sie diesen Typ in einer Funktionsdeklaration verwenden möchten, sollten Sie einen normalen Typ festlegen. Oder ändern Sie einfach Ihre Abfrage, um eine IENumerable<String> zurückzugeben und bei diesem Typ zu bleiben.

Oder geben Sie IEnumerable<KeyValuePair<Int32, String>> mithilfe der folgenden SELECT-Anweisung zurück.

select new KeyValuePair<Int32, String>(id, m.Groups[2].Value) 

Answer 2

Eine Sache zu erinnern ist, dass konvertieren LINQ Aussagen deferred execution verwenden. Das bedeutet, dass Ihre LINQ-Anweisung nicht tatsächlich ausgeführt wird, bis Sie entweder in einer foreach-Anweisung darüber iterieren oder die .ToList()-Methode unter myLine aufrufen. versuchen
Für Ihr Beispiel zu ändern:

return myLine; 

An:

return myLine.ToList(); 

Answer 3

Die Methodensignatur auf SearchItem zeigt an, dass das Verfahren ein IEnumerable<string> gibt aber den anonymen Typ in Ihrer LINQ-Abfrage deklarierte ist nicht vom Typ string. Wenn Sie dieselbe Methodensignatur beibehalten möchten, müssen Sie Ihre Abfrage so ändern, dass nur string s ausgewählt wird. z.B.

return myLine.Select(a => a.Text); 

Wenn Sie darauf bestehen, auf die Daten durch Ihre Frage ausgewählt Rückkehr, können Sie eine IEnumerable<object> zurück, wenn Sie Ihre return Anweisung ersetzen mit

return myLine.Cast<object>(); 

Dann können Sie die Objekte mithilfe von Reflektion verbrauchen.

Aber wirklich, wenn Sie einen anonymen Typ außerhalb der Methode verbrauchen, in der es deklariert wird, sollten Sie eine Klasse definieren und die Methode IEnumerable dieser Klasse zurückgeben. Anonyme Arten sind Bequemlichkeit, aber sie unterliegen Missbrauch.

Answer 4

Ihre Funktion versucht IEnumerable <String>, zurückzukehren, wenn die LINQ-Anweisung Sie tatsächlich ausführen, um ein IEnumerable <T> zurückkehrt, wo T eine Kompilierung-erzeugten Typ ist. Anonyme Typen sind nicht immer anonym, da sie nach der Kompilierung des Codes einen konkreten Typ annehmen.

Anonyme Typen können jedoch nur in dem Umfang verwendet werden, in dem sie erstellt wurden, da sie kurzlebig sind bis sie kompiliert wurden.Um Ihre Bedürfnisse im Beispiel zu unterstützen Sie zur Verfügung gestellt, würde ich die einfachste Lösung, sagen ist eine einfache Einheit zu schaffen, die die Ergebnisse der Abfrage speichert:

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 { ... } 
} 

Allerdings, wenn Ihr Ziel ist nicht eine Art abzurufen

IEnumerable<string> lines = from ... select m.Groups[2].Value; 

ich hoffe, dass Ihr Verständnis von LINQ zu klären hilft, enumerables und anonyme Typen: Objekt, und Sie sind nur daran interessiert, sagen wir, den Weg ... dann können Sie immer noch eine IEnumerable <Zeichenfolge> erzeugen. :)

Answer 5

Ich bin nicht unbedingt diese Empfehlung ... Es ist eine Art der Subversion des Typs System, aber man könnte dies tun: Ihre Methode

1) Signatur ändern IEnumerable (die nicht generische zurückzukehren)

2) fügen Sie einen cast by example Helfer:

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) dann die Methode in etwa so nennen:

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); 
} 

Und Sie sind fertig.

Der Schlüssel dazu ist die Tatsache, dass die Typen wiederverwendet werden, wenn Sie einen anonymen Typ mit der gleichen Reihenfolge, Typen und Eigenschaftsnamen an zwei Stellen erstellen. Wenn Sie dies wissen, können Sie Generika verwenden, um Reflexionen zu vermeiden.

hoffe, das hilft Alex