Mengonversi secara bebas antara List <T> dan IEnumerable <T>

Bagaimana cara mengubah a List<MyObject>menjadi an IEnumerable<MyObject>dan kemudian kembali lagi?

Saya ingin melakukan ini untuk menjalankan serangkaian pernyataan LINQ pada Daftar, misalnya Sort()

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

A List<T>adalah IEnumerable<T>, jadi sebenarnya, tidak perlu 'mengubah' a List<T>menjadi IEnumerable<T>. Karena a List<T>adalah IEnumerable<T>, Anda cukup menetapkan a List<T>ke variabel tipe IEnumerable<T>.

Sebaliknya, tidak semua IEnumerable<T>adalah List<T>offcourse, jadi Anda harus memanggil ToList()metode anggota IEnumerable<T>.

A List<T>sudah menjadi IEnumerable<T>, jadi Anda dapat menjalankan pernyataan LINQ langsung pada List<T>variabel Anda .

Jika Anda tidak melihat metode ekstensi LINQ seperti yang OrderBy()saya duga, itu karena Anda tidak memiliki using System.Linqarahan di file sumber Anda.

Anda perlu mengubah hasil ekspresi LINQ kembali menjadi List<T>secara eksplisit, meskipun:

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

Selain: Perhatikan bahwa operator LINQ standar (seperti contoh sebelumnya) tidak mengubah daftar yang ada - list.OrderBy(...).ToList()akan membuat daftar baru berdasarkan urutan yang diurutkan ulang. Namun, cukup mudah untuk membuat metode ekstensi yang memungkinkan Anda menggunakan lambda dengan 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)));
}

Kemudian Anda dapat menggunakan:

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

Ini memperbarui daftar yang ada dengan cara yang sama seperti List<T>.Sortbiasanya.

Mengonversi List<T>menjadiIEnumerable<T>

List<T>implement IEnumerable<T>(dan banyak lainnya seperti IList<T>, ICollection<T>) oleh karena itu tidak perlu mengonversi List kembali ke IEnumerable karena sudah menjadi IEnumerable<T>.

Contoh:

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;

Anda juga bisa menggunakan Enumerable.AsEnumerable()metode

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

Mengonversi IEnumerable<T>menjadiList<T>

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

Ini berguna dalam Entity Framework .

Untuk mencegah duplikasi dalam memori, resharper menyarankan ini:

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

.ToList () mengembalikan daftar baru yang tidak bisa diubah. Jadi perubahan pada listAgain tidak mempengaruhi myList dalam jawaban @Tamas Czinege. Ini benar dalam kebanyakan kasus untuk setidaknya dua alasan: Ini membantu mencegah perubahan di satu area yang mempengaruhi area lain (kopling longgar), dan ini sangat mudah dibaca, karena kita seharusnya tidak mendesain kode dengan masalah kompiler.

Tetapi ada contoh tertentu, seperti berada dalam loop ketat atau bekerja pada sistem memori tertanam atau rendah, di mana pertimbangan compiler harus dipertimbangkan.