Converta livremente entre List <T> e IEnumerable <T>

Como posso converter a List<MyObject>em IEnumerable<MyObject>e depois voltar?

Quero fazer isso para executar uma série de instruções LINQ na Lista, por exemplo Sort()

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

A List<T>é um IEnumerable<T>, então, na verdade, não há necessidade de 'converter' a List<T>em um IEnumerable<T>. Como a List<T>é um IEnumerable<T>, você pode simplesmente atribuir a List<T>a uma variável do tipo IEnumerable<T>.

Ao contrário, nem todo IEnumerable<T>é um List<T>offcourse, então você terá que chamar o ToList()método membro do IEnumerable<T>.

A List<T>já é um IEnumerable<T>, portanto, você pode executar instruções LINQ diretamente em sua List<T>variável.

Se você não vir os métodos de extensão LINQ, como OrderBy()estou supondo, é porque você não tem uma using System.Linqdiretiva no arquivo de origem.

Você precisa converter o resultado da expressão LINQ de volta em um List<T>explicitamente, no entanto:

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

À parte: Observe que os operadores LINQ padrão (conforme o exemplo anterior) não alteram a lista existente - list.OrderBy(...).ToList()criarão uma nova lista com base na sequência reordenada. É muito fácil, no entanto, criar um método de extensão que permite usar lambdas com 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)));
}

Então você pode usar:

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

Isso atualiza a lista existente da mesma maneira que List<T>.Sortnormalmente faz.

Convertendo List<T>paraIEnumerable<T>

List<T>implementa IEnumerable<T>(e muitos outros como IList<T>, ICollection<T>), portanto, não há necessidade de converter um List de volta em IEnumerable, pois ele já a IEnumerable<T>.

Exemplo:

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;

Você também pode usar o Enumerable.AsEnumerable()método

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

Convertendo IEnumerable<T>paraList<T>

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

Isso é útil no Entity Framework .

Para evitar a duplicação na memória, resharper está sugerindo o seguinte:

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

.ToList () retorna uma nova lista imutável. Portanto, as alterações em listAgain não afetam myList na resposta do @Tamas Czinege. Isso está correto na maioria dos casos por pelo menos dois motivos: Isso ajuda a evitar mudanças em uma área afetando a outra área (acoplamento fraco) e é muito legível, uma vez que não devemos projetar código com preocupações de compilador.

Mas há certos casos, como estar em um loop apertado ou trabalhar em um sistema embutido ou com pouca memória, onde as considerações do compilador devem ser levadas em consideração.