Warum Kovarianz und Kontravarianz den Wertetyp nicht unterstützen

IEnumerable<T>ist eine Co-Variante, unterstützt jedoch keinen Werttyp, sondern nur einen Referenztyp. Der folgende einfache Code wurde erfolgreich kompiliert:

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

Beim Wechsel von stringzu intwird jedoch ein kompilierter Fehler angezeigt:

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

Der Grund wird in MSDN erklärt :

Die Abweichung gilt nur für Referenztypen. Wenn Sie einen Werttyp für einen Variantentypparameter angeben, ist dieser Typparameter für den resultierenden konstruierten Typ unveränderlich.

Ich habe gesucht und festgestellt, dass einige Fragen den Grund für das Boxen zwischen Werttyp und Referenztyp genannt haben . Aber es klärt mich immer noch nicht auf, warum Boxen der Grund ist?

Könnte jemand bitte eine einfache und detaillierte Erklärung geben, warum Kovarianz und Kontravarianz den Werttyp nicht unterstützen und wie sich das Boxen darauf auswirkt?

Grundsätzlich gilt Varianz, wenn die CLR sicherstellen kann, dass keine repräsentativen Änderungen an den Werten vorgenommen werden müssen. Referenzen sehen alle gleich aus - Sie können also eine IEnumerable<string>als IEnumerable<object>ohne Änderung der Darstellung verwenden. Der native Code selbst muss nicht wissen, was Sie mit den Werten tun, solange die Infrastruktur garantiert hat, dass er definitiv gültig ist.

Bei Werttypen funktioniert das nicht - um einen IEnumerable<int>als zu behandelnIEnumerable<object> , müsste der Code, der die Sequenz verwendet, wissen, ob eine Boxkonvertierung durchgeführt werden soll oder nicht.

Vielleicht möchten Sie Eric Lipperts Blog-Beitrag über Repräsentation und Identität lesen um mehr über dieses Thema im Allgemeinen zu erfahren.

EDIT: Nachdem ich Erics Blog-Post selbst noch einmal gelesen habe, geht es mindestens genauso um Identität wie um Repräsentation, obwohl die beiden miteinander verbunden sind. Bestimmtes:

Aus diesem Grund erfordern kovariante und kontravariante Konvertierungen von Schnittstellen- und Delegattypen, dass alle unterschiedlichen Typargumente Referenztypen sind. Um sicherzustellen, dass eine Variantenreferenzkonvertierung immer identitätserhaltend ist, müssen alle Konvertierungen mit Typargumenten auch identitätserhaltend sein. Der einfachste Weg, um sicherzustellen, dass alle nicht trivialen Konvertierungen für Typargumente identitätserhaltend sind, besteht darin, sie auf Referenzkonvertierungen zu beschränken.

Es ist vielleicht einfacher zu verstehen, wenn Sie über die zugrunde liegende Darstellung nachdenken (obwohl dies wirklich ein Implementierungsdetail ist). Hier ist eine Sammlung von Zeichenfolgen:

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

Sie können sich stringsdie folgende Darstellung vorstellen:

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

Es ist eine Sammlung von drei Elementen, die jeweils auf eine Zeichenfolge verweisen. Sie können dies in eine Sammlung von Objekten umwandeln:

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

Im Grunde ist es die gleiche Darstellung, außer dass die Referenzen jetzt Objektreferenzen sind:

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

Die Darstellung ist die gleiche. Die Referenzen werden nur unterschiedlich behandelt; Sie können nicht mehr auf die string.LengthUnterkunft zugreifen, aber Sie können trotzdem anrufen object.GetHashCode(). Vergleichen Sie dies mit einer Sammlung von Ints:

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

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

Um dies in ein zu konvertieren, müssen IEnumerable<object>die Daten durch Boxen der Ints konvertiert werden:

[0]: Objektreferenz -> 1
[1]: Objektreferenz -> 2
[2]: Objektreferenz -> 3

Diese Konvertierung erfordert mehr als eine Besetzung.

Ich denke, alles beginnt mit der Definition von LSP(Liskov-Substitutionsprinzip), die folgende Bedingungen erfüllt:

Wenn q (x) eine Eigenschaft ist, die für Objekte x vom Typ T beweisbar ist, sollte q (y) für Objekte y vom Typ S gelten, wobei S ein Subtyp von T ist.

Werttypen können beispielsweise intnicht durch objectin ersetzt werden C#. Beweisen ist sehr einfach:

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

Dies gibt falseauch dann zurück , wenn wir dem Objekt dieselbe "Referenz" zuweisen .

Es kommt auf ein Implementierungsdetail an: Werttypen werden anders als Referenztypen implementiert.

Wenn Sie erzwingen, dass Werttypen als Referenztypen behandelt werden (z. B. Boxen, z. B. indem Sie über eine Schnittstelle auf sie verweisen), können Sie Abweichungen erhalten.

Der einfachste Weg, um den Unterschied zu erkennen, besteht darin, einfach Folgendes zu betrachten Array: Ein Array von Werttypen wird zusammenhängend (direkt) im Speicher zusammengestellt, wobei ein Array von Referenztypen nur die Referenz (einen Zeiger) zusammenhängend im Speicher hat; Die Objekte, auf die verwiesen wird, werden separat zugeordnet.

Das andere (verwandte) Problem (*) ist, dass (fast) alle Referenztypen für Varianzzwecke dieselbe Darstellung haben und viel Code den Unterschied zwischen den Typen nicht kennen muss, so dass eine Co- und Kontra-Varianz möglich (und leicht) ist implementiert - oft nur durch Weglassen einer zusätzlichen Typprüfung).

(*) Es kann das gleiche Problem gesehen werden ...