Mengapa saya bisa menginisialisasi Daftar seperti array di C #?

Hari ini saya terkejut menemukan itu di C # yang bisa saya lakukan:

List<int> a = new List<int> { 1, 2, 3 };

Mengapa saya bisa melakukan ini? Konstruktor apa yang disebut? Bagaimana saya bisa melakukan ini dengan kelas saya sendiri? Saya tahu bahwa ini adalah cara untuk menginisialisasi array tetapi array adalah item bahasa dan Daftar adalah objek sederhana ...

Ini adalah bagian dari sintaks initializer koleksi di .NET. Anda dapat menggunakan sintaks ini pada koleksi yang Anda buat selama:

• Ini mengimplementasikan IEnumerable(lebih disukai IEnumerable<T>)

• Itu memiliki metode bernama Add(...)

Apa yang terjadi adalah konstruktor default dipanggil, dan kemudian Add(...)dipanggil untuk setiap anggota penginisialisasi.

Dengan demikian, kedua blok ini kira-kira identik:

List<int> a = new List<int> { 1, 2, 3 };

Dan

List<int> temp = new List<int>();
temp.Add(1);
temp.Add(2);
temp.Add(3);
List<int> a = temp;

Anda dapat memanggil konstruktor alternatif jika Anda mau, misalnya untuk mencegah ukuran yang terlalu besar List<T>selama pertumbuhan, dll:

// Notice, calls the List constructor that takes an int arg
// for initial capacity, then Add()'s three items.
List<int> a = new List<int>(3) { 1, 2, 3, }

Perhatikan bahwa Add()metode ini tidak perlu mengambil satu item, misalnya Add()metode untuk Dictionary<TKey, TValue>mengambil dua item:

var grades = new Dictionary<string, int>
    {
        { "Suzy", 100 },
        { "David", 98 },
        { "Karen", 73 }
    };

Secara kasar identik dengan:

var temp = new Dictionary<string, int>();
temp.Add("Suzy", 100);
temp.Add("David", 98);
temp.Add("Karen", 73);
var grades = temp;

Jadi, untuk menambahkan ini ke kelas Anda sendiri, yang perlu Anda lakukan, seperti yang disebutkan, adalah mengimplementasikan IEnumerable(sekali lagi, lebih disukai IEnumerable<T>) dan membuat satu atau lebih Add()metode:

public class SomeCollection<T> : IEnumerable<T>
{
    // implement Add() methods appropriate for your collection
    public void Add(T item)
    {
        // your add logic    
    }

    // implement your enumerators for IEnumerable<T> (and IEnumerable)
    public IEnumerator<T> GetEnumerator()
    {
        // your implementation
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Kemudian Anda dapat menggunakannya seperti koleksi BCL lakukan:

public class MyProgram
{
    private SomeCollection<int> _myCollection = new SomeCollection<int> { 13, 5, 7 };    

    // ...
}

(Untuk informasi lebih lanjut, lihat MSDN )

Ini disebut gula sintaksis .

List<T> adalah kelas "sederhana", tetapi kompiler memberikan perlakuan khusus untuknya agar hidup Anda lebih mudah.

Yang ini disebut initializer koleksi . Anda perlu menerapkan IEnumerable<T>dan Addmetode.

Menurut Spesifikasi C # Versi 3.0 "Objek koleksi yang digunakan penginisialisasi koleksi harus dari tipe yang mengimplementasikan System.Collections.Generic.ICollection untuk tepat satu T."

Namun, informasi ini tampaknya tidak akurat pada tulisan ini; lihat klarifikasi Eric Lippert dalam komentar di bawah.

Ini berfungsi berkat inisialisasi koleksi yang pada dasarnya memerlukan koleksi untuk menerapkan metode Tambahkan dan itu akan bekerja untuk Anda.

Hal keren lainnya tentang inisialisasi koleksi adalah Anda dapat memiliki banyak kelebihan Addmetode dan Anda dapat memanggil mereka semua di inisialisasi yang sama! Misalnya ini berfungsi:

public class MyCollection<T> : IEnumerable<T>
{
    public void Add(T item, int number)
    {

    }
    public void Add(T item, string text) 
    {

    }
    public bool Add(T item) //return type could be anything
    {

    }
}

var myCollection = new MyCollection<bool> 
{
    true,
    { false, 0 },
    { true, "" },
    false
};

Itu memanggil kelebihan yang benar. Juga, hanya mencari metode dengan nama Add, tipe pengembalian bisa apa saja.

Array seperti sintaks sedang diubah dalam serangkaian Add()panggilan.

Untuk melihat ini dalam contoh yang jauh lebih menarik, pertimbangkan kode berikut di mana saya melakukan dua hal menarik yang terdengar ilegal pertama di C #, 1) mengatur properti readonly, 2) mengatur daftar dengan array seperti inisialisasi.

public class MyClass
{   
    public MyClass()
    {   
        _list = new List<string>();
    }
    private IList<string> _list;
    public IList<string> MyList 
    { 
        get
        { 
            return _list;
        }
    }
}
//In some other method
var sample = new MyClass
{
    MyList = {"a", "b"}
};

Kode ini akan bekerja dengan sempurna, walaupun 1) MyList hanya bisa dibaca dan 2) Saya menetapkan daftar dengan penginisialisasi array.

Alasan mengapa ini bekerja, adalah karena dalam kode yang merupakan bagian dari objek intializer kompiler selalu mengubah {}sintaksis seperti ke serangkaian Add()panggilan yang sangat legal bahkan pada bidang yang hanya dibaca.