Neden kovaryans ve kontravarlık değer türünü desteklemiyor?

IEnumerable<T>bir ko-varyantı ancak değeri türü, sadece tek referans türü desteklemez. Aşağıdaki basit kod başarıyla derlenmiştir:

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

Ama değişen stringTo intderlenmiş hatayı alırsınız:

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

Nedeni MSDN'de açıklanmıştır :

Varyans yalnızca referans türleri için geçerlidir; Bir varyant türü parametresi için bir değer türü belirtirseniz, bu tür parametresi sonuçta ortaya çıkan yapılandırılmış tür için değişmez.

Araştırdım ve bazı soruların nedeninin değer türü ile referans türü arasında bir karmaşa olduğunu belirttim . Ama neden boks olmanın sebebi hala fikrimi pek açmıyor?

Birisi lütfen basit ve ayrıntılı bir açıklama yapabilir mi kovaryans ve kontravaryans değer türünü desteklemiyor ve boks bunu nasıl etkiliyor?

Temel olarak, varyans, CLR değerlerde herhangi bir temsili değişiklik yapmasına gerek olmadığından emin olabildiğinde geçerlidir . Referansların tümü aynı görünür - böylece temsilinde herhangi bir değişiklik olmadan bir an IEnumerable<string>olarak kullanabilirsiniz IEnumerable<object>; Altyapı kesinlikle geçerli olacağını garanti ettiği sürece yerel kodun kendisinin değerlerle ne yaptığınızı bilmesine gerek yoktur.

Değer türleri için bu işe yaramaz - bir'yi bir IEnumerable<int>olarak ele almak için IEnumerable<object>, diziyi kullanan kodun bir boks dönüşümü yapıp yapmayacağını bilmesi gerekir.

Genel olarak bu konuyla ilgili daha fazla bilgi için Eric Lippert'in temsil ve kimlik hakkındaki blog gönderisini okumak isteyebilirsiniz .

DÜZENLEME: Eric'in blog gönderisini kendim okuduktan sonra , ikisi bağlantılı olsa da, en azından temsil kadar kimlik ile ilgili . Özellikle:

Bu nedenle arabirim ve temsilci türlerinin kovaryant ve karşıt değişken dönüşümleri, tüm değişken tür bağımsız değişkenlerin başvuru türlerinde olmasını gerektirir. Bir varyant referans dönüşümünün her zaman kimliği koruduğundan emin olmak için, tür bağımsız değişkenlerini içeren tüm dönüşümlerin de kimliği koruyan olması gerekir. Tür bağımsız değişkenlerindeki önemsiz olmayan tüm dönüştürmelerin kimlik korumalı olduğundan emin olmanın en kolay yolu, bunları referans dönüşümler olarak sınırlamaktır.

Altta yatan temsil hakkında düşünürseniz anlamak belki daha kolaydır (bu gerçekten bir uygulama ayrıntısı olsa bile). İşte dizelerden oluşan bir koleksiyon:

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

stringsAşağıdaki temsile sahip olduğunu düşünebilirsiniz :

[0]: dize başvurusu -> "A"
[1]: dize başvurusu -> "B"
[2]: dize başvurusu -> "C"

Her biri bir dizeye referans olan üç öğeden oluşan bir koleksiyondur. Bunu bir nesne koleksiyonuna dönüştürebilirsiniz:

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

Temelde aynı temsildir, ancak artık referanslar nesne referanslarıdır:

[0]: nesne başvurusu -> "A"
[1]: nesne başvurusu -> "B"
[2]: nesne referansı -> "C"

Temsil aynıdır. Referanslar sadece farklı şekilde ele alınır; artık string.Lengthmülke erişemezsiniz, ancak yine de arayabilirsiniz object.GetHashCode(). Bunu bir intler koleksiyonuyla karşılaştırın:

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

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

Bunu bir IEnumerable<object>veriye dönüştürmek için , verinin ints kutulanılarak dönüştürülmesi gerekir:

[0]: nesne başvurusu -> 1
[1]: nesne referansı -> 2
[2]: nesne referansı -> 3

Bu dönüşüm, bir dökümden fazlasını gerektirir.

Bence her şey, tırmanan LSP(Liskov İkame İlkesi) tanımından başlar :

q (x), T türündeki x nesneleri hakkında kanıtlanabilir bir özellikse, q (y), S'nin T'nin bir alt türü olduğu S türündeki y nesneleri için doğru olmalıdır.

Ancak, örneğin değer türleri, in intyerine geçemez . Kanıtlamak çok basit:objectC#

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

Nesneye aynı "referansı" atasak falsebile bu geri döner .

Bir uygulama ayrıntısına iner: Değer türleri, referans türlerinden farklı şekilde uygulanır.

Değer türlerini referans türleri olarak ele alınmaya zorlarsanız (örneğin, bir arabirim aracılığıyla onlara başvurarak onları kutuya alırsanız) varyans elde edebilirsiniz.

Farkı görmenin en kolay yolu basitçe şunu düşünmektir Array: bir Değer türleri dizisi, bellekte bitişik (doğrudan) olarak bir araya getirilir, burada bir Referans türleri dizisi yalnızca bellekte bitişik olarak başvuruya (bir işaretçi) sahiptir; işaret edilen nesneler ayrı olarak tahsis edilir.

Diğer (ilgili) sorun (*), (hemen hemen) tüm Referans türlerinin varyans amaçları için aynı gösterime sahip olması ve çoğu kodun türler arasındaki farkı bilmesine gerek olmamasıdır, bu nedenle birlikte ve ters varyans mümkündür (ve kolayca uygulanır - genellikle sadece ekstra tip kontrolünün ihmal edilmesiyle).

(*) Aynı sorun olarak görünebilir ...