Converti liberamente tra List <T> e IEnumerable <T>

Come posso convertire un List<MyObject>a in un IEnumerable<MyObject>e poi di nuovo?

Voglio farlo per eseguire una serie di istruzioni LINQ sull'elenco, ad es Sort()

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

A List<T>è an IEnumerable<T>, quindi in realtà non è necessario "convertire" a List<T>in an IEnumerable<T>. Poiché a List<T>è an IEnumerable<T>, puoi semplicemente assegnare a List<T>a una variabile di tipo IEnumerable<T>.

Al contrario, non tutti IEnumerable<T>sono fuori corso List<T>, quindi dovrai chiamare il ToList()metodo membro di IEnumerable<T>.

A List<T>è già un IEnumerable<T>, quindi puoi eseguire istruzioni LINQ direttamente sulla tua List<T>variabile.

Se non vedi i metodi di estensione LINQ come OrderBy()immagino sia perché non hai una using System.Linqdirettiva nel tuo file sorgente.

List<T>Tuttavia, è necessario riconvertire il risultato dell'espressione LINQ in un esplicito:

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

A parte: si noti che gli operatori LINQ standard (come nell'esempio precedente) non modificano l' elenco esistente : list.OrderBy(...).ToList()creeranno un nuovo elenco in base alla sequenza riordinata. È abbastanza facile, tuttavia, creare un metodo di estensione che ti consenta di utilizzare lambda con List<T>.Sort:

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

Quindi puoi usare:

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

Questo aggiorna l' elenco esistente nello stesso modo in cui List<T>.Sortfa di solito.

Conversione List<T>inIEnumerable<T>

List<T>implementa IEnumerable<T>(e molti altri come IList<T>, ICollection<T>) quindi non è necessario riconvertire un List in IEnumerable poiché è già unIEnumerable<T> .

Esempio:

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;

Puoi anche usare il Enumerable.AsEnumerable()metodo

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

Conversione IEnumerable<T>inList<T>

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

Ciò è utile in Entity Framework .

Per evitare la duplicazione in memoria, resharper suggerisce questo:

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

.ToList () restituisce un nuovo elenco non modificabile. Quindi le modifiche a listAgain non hanno effetto su myList nella risposta @Tamas Czinege. Questo è corretto nella maggior parte dei casi per almeno due ragioni: questo aiuta a prevenire i cambiamenti in un'area che influiscono sull'altra area (accoppiamento libero), ed è molto leggibile, poiché non dovremmo progettare codice con problemi di compilazione.

Ma ci sono alcuni casi, come trovarsi in un ciclo stretto o lavorare su un sistema incorporato o con poca memoria, in cui è necessario prendere in considerazione le considerazioni del compilatore.