webentwicklung-frage-antwort-db.com.de

Frei konvertieren zwischen List <T> und IEnumerable <T>

Wie kann ich einen List<MyObject> In einen IEnumerable<MyObject> Umwandeln und dann wieder zurück?

Ich möchte dies tun, um eine Reihe von LINQ-Anweisungen in der Liste auszuführen, z. G. Sort()

102
TK.
List<string> myList = new List<string>();
IEnumerable<string> myEnumerable = myList;
List<string> listAgain = myEnumerable.ToList();
146
Tamas Czinege

Ein List<T> Ist ein IEnumerable<T>. Es ist also nicht erforderlich, einen List<T> In einen IEnumerable<T> Umzuwandeln. Da ein List<T> Ein IEnumerable<T> Ist, können Sie einer Variablen vom Typ List<T> Einfach einen IEnumerable<T> Zuweisen.

Umgekehrt ist nicht jeder IEnumerable<T> Eine List<T> - Methode, daher müssen Sie die Member-Methode ToList() von IEnumerable<T> Aufrufen.

21

Ein List<T> Ist bereits ein IEnumerable<T>, Sodass Sie LINQ-Anweisungen direkt für Ihre List<T> - Variable ausführen können.

Wenn Sie die LINQ-Erweiterungsmethoden wie OrderBy() nicht sehen, liegt das vermutlich daran, dass Ihre Quelldatei keine using System.Linq - Direktive enthält.

Sie müssen das Ergebnis des LINQ-Ausdrucks jedoch explizit in ein List<T> Zurückkonvertieren:

List<Customer> list = ...
list = list.OrderBy(customer => customer.Name).ToList()
9
Dan Berindei

Abgesehen davon: Beachten Sie, dass die Standard-LINQ-Operatoren (wie im vorherigen Beispiel) die vorhandene Liste - list.OrderBy(...).ToList() nicht ändern, um eine neue Liste basierend auf der neu geordneten Reihenfolge zu erstellen. Es ist jedoch ziemlich einfach, eine Erweiterungsmethode zu erstellen, mit der Sie Lambdas mit List<T>.Sort Verwenden können:

static void Sort<TSource, TValue>(this List<TSource> list,
    Func<TSource, TValue> selector)
{
    var comparer = Comparer<TValue>.Default;
    list.Sort((x,y) => comparer.Compare(selector(x), selector(y)));
}

static void SortDescending<TSource, TValue>(this List<TSource> list,
    Func<TSource, TValue> selector)
{
    var comparer = Comparer<TValue>.Default;
    list.Sort((x,y) => comparer.Compare(selector(y), selector(x)));
}

Dann können Sie verwenden:

list.Sort(x=>x.SomeProp); // etc

Dadurch wird die vorhandene Liste auf dieselbe Weise aktualisiert, wie dies normalerweise bei List<T>.Sort Der Fall ist.

5
Marc Gravell

Konvertieren von List<T> In IEnumerable<T>

List<T> Implementiert IEnumerable<T> (Und viele andere wie IList<T>, ICollection<T>), Sodass eine Liste nicht zurück in IEnumerable konvertiert werden muss, da sie bereits einen IEnumerable<T> Enthält.

Beispiel:

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Person person1 = new Person() { Id = 1, Name = "Person 1" };
Person person2 = new Person() { Id = 2, Name = "Person 2" };
Person person3 = new Person() { Id = 3, Name = "Person 3" };

List<Person> people = new List<Person>() { person1, person2, person3 };

//Converting to an IEnumerable
IEnumerable<Person> IEnumerableList = people;

Sie können auch die Methode Enumerable.AsEnumerable() verwenden

IEnumerable<Person> iPersonList = people.AsEnumerable();

Konvertieren von IEnumerable<T> In List<T>

IEnumerable<Person> OriginallyIEnumerable = new List<Person>() { person1, person2 };
List<Person> convertToList = OriginallyIEnumerable.ToList();

Dies ist nützlich in Entity Framework .

1
Nipuna

Um Duplikationen im Speicher zu vermeiden, schlägt Resharper Folgendes vor:

List<string> myList = new List<string>();
IEnumerable<string> myEnumerable = myList;
List<string> listAgain = myList as List<string>() ?? myEnumerable.ToList();

.ToList () gibt eine neue unveränderliche Liste zurück. Änderungen an listAgain wirken sich also nicht auf myList in @Tamas Czinege aus. Dies ist in den meisten Fällen aus mindestens zwei Gründen richtig: Dies verhindert Änderungen in einem Bereich, die sich auf den anderen auswirken (lose Kopplung), und es ist sehr lesbar, da wir keinen Code mit Compilerproblemen entwerfen sollten.

Es gibt jedoch bestimmte Fälle, z. B. eine enge Schleife oder die Arbeit an einem eingebetteten System oder einem System mit geringem Arbeitsspeicher, in denen Compilerüberlegungen berücksichtigt werden sollten.

0
TamusJRoyce