Mengapa kovarians dan contravariance tidak mendukung tipe nilai

IEnumerable<T>adalah co-varian tetapi tidak mendukung tipe nilai, hanya tipe referensi saja. Kode sederhana di bawah ini berhasil dikompilasi:

IEnumerable<string> strList = new List<string>();
IEnumerable<object> objList = strList;

Tetapi mengubah dari stringmenjadi intakan mendapatkan kesalahan yang dikompilasi:

IEnumerable<int> intList = new List<int>();
IEnumerable<object> objList = intList;

Alasannya dijelaskan dalam MSDN :

Varians hanya berlaku untuk tipe referensi; jika Anda menentukan tipe nilai untuk parameter tipe varian, parameter tipe itu tidak tetap untuk tipe konstruksi yang dihasilkan.

Saya telah mencari dan menemukan bahwa beberapa pertanyaan menyebutkan alasannya adalah tinju antara tipe nilai dan tipe referensi . Tapi itu masih belum menjernihkan pikiran saya mengapa tinju adalah alasannya?

Bisakah seseorang tolong berikan penjelasan yang sederhana dan terperinci mengapa kovarians dan contravariance tidak mendukung tipe nilai dan bagaimana tinju mempengaruhi ini?

Pada dasarnya, varians berlaku ketika CLR dapat memastikan bahwa CLR tidak perlu melakukan perubahan representasional terhadap nilai-nilai tersebut. Referensi semua terlihat sama - sehingga Anda dapat menggunakan IEnumerable<string>sebagai IEnumerable<object>tanpa perubahan representasi; kode asli itu sendiri tidak perlu tahu apa yang Anda lakukan dengan nilai-nilai sama sekali, asalkan infrastruktur telah menjamin bahwa itu pasti akan valid.

Untuk tipe nilai, itu tidak berfungsi - untuk menganggapnya IEnumerable<int>sebagai IEnumerable<object>, kode yang menggunakan urutan harus tahu apakah akan melakukan konversi tinju atau tidak.

Anda mungkin ingin membaca posting blog Eric Lippert tentang representasi dan identitas untuk lebih lanjut tentang topik ini secara umum.

EDIT: Memiliki membaca ulang posting blog Eric sendiri, setidaknya tentang identitas sebagai representasi, meskipun keduanya terkait. Khususnya:

Inilah sebabnya mengapa konversi kovarian dan contravarian antarmuka dan jenis delegasi mengharuskan semua argumen jenis yang berbeda dari jenis referensi. Untuk memastikan bahwa konversi referensi varian selalu mempertahankan identitas, semua konversi yang melibatkan argumen tipe juga harus mempertahankan identitas. Cara termudah untuk memastikan bahwa semua konversi non-sepele pada argumen tipe dipertahankan identitas adalah dengan membatasi mereka untuk menjadi konversi referensi.

Mungkin lebih mudah untuk dipahami jika Anda memikirkan representasi yang mendasarinya (meskipun ini benar-benar detail implementasi). Berikut ini adalah kumpulan string:

IEnumerable<string> strings = new[] { "A", "B", "C" };

Anda dapat menganggapnya stringssebagai memiliki representasi berikut:

[0]: referensi string -> "A"
[1]: referensi string -> "B"
[2]: referensi string -> "C"

Ini adalah kumpulan dari tiga elemen, masing-masing menjadi referensi ke string. Anda bisa melemparkan ini ke koleksi objek:

IEnumerable<object> objects = (IEnumerable<object>) strings;

Pada dasarnya itu adalah representasi yang sama kecuali sekarang referensi adalah referensi objek:

[0]: referensi objek -> "A"
[1]: referensi objek -> "B"
[2]: referensi objek -> "C"

Representasinya sama. Referensi hanya diperlakukan secara berbeda; Anda tidak lagi dapat mengakses string.Lengthproperti tetapi Anda masih dapat menelepon object.GetHashCode(). Bandingkan ini dengan koleksi int:

IEnumerable<int> ints = new[] { 1, 2, 3 };

[0]: int = 1
[1]: int = 2
[2]: int = 3

Untuk mengonversikan ini ke IEnumerable<object>data, harus dikonversi dengan memasukkan int:

[0]: referensi objek -> 1
[1]: referensi objek -> 2
[2]: referensi objek -> 3

Konversi ini membutuhkan lebih dari sekadar pemeran.

Saya pikir semuanya dimulai dari definisi LSP(Prinsip Pergantian Liskov), yang meliputi:

jika q (x) adalah properti yang dapat dibuktikan tentang objek x dari tipe T maka q (y) harus benar untuk objek y dari tipe S di mana S adalah subtipe dari T.

Namun tipe nilai, misalnya inttidak bisa menjadi pengganti objectin C#. Buktikan sangat sederhana:

int myInt = new int();
object obj1 = myInt ;
object obj2 = myInt ;
return ReferenceEquals(obj1, obj2);

Ini mengembalikan falsebahkan jika kita menetapkan "referensi" yang sama ke objek.

Itu datang ke detail implementasi: Jenis nilai diimplementasikan secara berbeda untuk jenis referensi.

Jika Anda memaksakan tipe nilai untuk diperlakukan sebagai tipe referensi (yaitu kotak mereka, misalnya dengan merujuk mereka melalui antarmuka) Anda bisa mendapatkan varians.

Cara termudah untuk melihat perbedaannya adalah dengan mempertimbangkan Array: sebuah array tipe Nilai disatukan dalam memori secara bersamaan (langsung), di mana sebagai array tipe Referensi hanya memiliki referensi (pointer) yang berdekatan dalam memori; objek yang ditunjuk dialokasikan secara terpisah.

Masalah (terkait) lainnya (*) adalah bahwa (hampir) semua tipe Referensi memiliki representasi yang sama untuk tujuan varians dan banyak kode tidak perlu mengetahui perbedaan antara jenis, sehingga co-dan kontra-varians dimungkinkan (dan mudah diimplementasikan - seringkali hanya dengan menghilangkan pemeriksaan tipe tambahan).

(*) Ini mungkin terlihat masalah yang sama ...