Warum ist Array nicht ein generischer Typ?

Geschichte

Welche Probleme würden entstehen, wenn arrays wurde ein generischer Typ?

Zurück in C# 1.0 Sie kopierten das Konzept von arrays, die hauptsächlich aus Java. Generika gab es damals noch nicht, aber die Macher dachten, Sie waren schlau und kopiert die gebrochen kovariante array-Semantik von Java-arrays haben. Dies bedeutet, dass Sie abziehen können Dinge wie diese, ohne einen compile-Zeit-Fehler (aber eine Laufzeit-Fehlermeldung statt):

Mammoth[] mammoths = new Mammoth[10];
Animal[] animals = mammoths;            //Covariant conversion
animals[1] = new Giraffe();             //Run-time exception

In C# 2.0 generics eingeführt wurden, aber keine kovariante/kontravariant generische Typen. Wenn arrays gemacht wurden generische, dann könnte Sie nicht wirken Mammoth[] zu Animal[]etwas, das Sie tun konnte, bevor (auch wenn es defekt war). Somit können arrays generische würde gebrochen haben viel code.

Nur in C# 4.0 wurden kovariante/kontravariant generische Typen für Schnittstellen eingeführt. Dies machte es möglich, zu beheben die gebrochenen array-Kovarianz-einmal und für alle. Aber auch dies würde gebrochen haben viel bestehenden code.

Array<Mammoth> mammoths = new Array<Mammoth>(10);
Array<Animal> animals = mammoths;           //Not allowed.
IEnumerable<Animals> animals = mammoths;    //Covariant conversion

Arrays implementieren generischer interfaces

Nicht warum arrays implementieren das generische IList<T>ICollection<T> und IEnumerable<T> Schnittstellen?

Dank einer runtime-trick jedes array T[] hat implementieren IEnumerable<T>ICollection<T> und IList<T> automatisch.¹ Von der Array - Klasse Dokumentation:

In der .NET Framework, version 2.0, Klasse Array implementiert die IList<T>ICollection<T>und IEnumerable<T> generischen Schnittstellen. Die Implementierungen zur Verfügung gestellt werden arrays zur Laufzeit, und daher nicht sichtbar sind, die Dokumentation, build-tools. Als Ergebnis werden die generischen Schnittstellen, erscheinen nicht in der Deklaration syntax für die Array-Klasse.

Können Sie alle Mitglieder des Schnittstellen implementiert arrays?

Nicht. Die Dokumentation setzt sich mit dieser Bemerkung:

Die wichtige Sache zu beachten sind, wenn Sie werfen ein array an eine dieser Schnittstellen ist, dass die Mitglieder, die hinzufügen, einfügen oder entfernen von Elementen werfen NotSupportedException.

Weil (zum Beispiel) ICollection<T> hat eine Add Methode, aber Sie können nicht hinzufügen, alles zu einem array. Es wird eine exception werfen. Dies ist ein weiteres Beispiel für einen frühen design-Fehler in der .NET-Framework mit der man Ausnahmen, die bei Ihnen bei der Laufzeit:

ICollection<Mammoth> collection = new Mammoth[10];  //Cast to interface type
collection.Add(new Mammoth());                      //Run-time exception

Und da ICollection<T> ist nicht kovariante (aus offensichtlichen Gründen), Sie kann das nicht tun:

ICollection<Mammoth> mammoths = new Array<Mammoth>(10);
ICollection<Animal> animals = mammoths;     //Not allowed

Natürlich gibt es nun die kovariante IReadOnlyCollection<T> interface , ist auch die Implementierung von arrays unter der Haube¹aber es enthält nur Count so hat es begrenzte Anwendungen.

Der Basis-Klasse Array

Wenn arrays wurden generische, würden wir noch brauchen, die nicht-generische Array Klasse?

In den frühen Tagen haben wir. Alle arrays implementieren die nicht-generische IList
ICollection und
IEnumerable Schnittstellen durch Ihre Basis-Klasse Array. Dies war die einzige vernünftige Möglichkeit zu geben, alle arrays von spezifischen Methoden und Schnittstellen, und ist der primäre nutzen der Array Basisklasse. Sie sehen, die gleiche Wahl für enums: Sie sind value-Typen Erben, die Mitglieder von Enum; und die Delegierten, dass Erben von MulticastDelegate.

Könnte die nicht-generische Basisklasse Array nun entfernt werden, die generics unterstützt werden?

Ja, der Methoden und Schnittstellen, die gemeinsam von allen arrays definiert werden kann, auf die generischen Array<T> Klasse, wenn es überhaupt zustande kam. Und dann könnte man schreiben, zum Beispiel Copy<T>(T[] source, T[] destination) statt Copy(Array source, Array destination) mit dem zusätzlichen Vorteil, eine gewisse Art der Sicherheit.

Jedoch von einem Objekt-Orientierte Programmier-Sicht ist es schön, einen gemeinsamen nicht-generische Basisklasse Array verwendet werden können, finden Sie alle array unabhängig von der Art Ihrer Elemente. So wie IEnumerable<T> erbt von IEnumerable (die ist noch in einige LINQ-Methoden).

Könnte die Array Basisklasse ableiten von Array<object>?

Nein, das würde eine zyklische Abhängigkeit erzeugen: Array<T> : Array : Array<object> : Array : .... Auch, dass würde bedeuten, Sie könnte Shop alle - Objekt in ein array (nachdem alle, alle arrays, die letztlich den Erben von Typ Array<object>).

Die Zukunft

Könnte die neue generische array-Typ Array<T> Hinzugefügt werden, ohne Auswirkungen auf bestehenden code zu viel?

Nicht. Während die syntax könnte gemacht werden, um zu passen, das vorhandene array-Kovarianz-konnte nicht verwendet werden.

Ein array ist ein spezieller Typ .NET. Es hat sogar seinen eigenen Anweisungen in die Common Intermediate Language. Wenn die .NET-und C# - Designer jemals entscheiden, zu gehen dieser Weg, Sie könnten machen die T[] syntax syntaktische Zucker für Array<T> (so wie T? ist syntaktischer Zucker für Nullable<T>), und noch verwenden Sie die spezielle Anleitung und Unterstützung, der die Zuweisung der arrays im Speicher zusammenhängend.

Jedoch, Sie würden die Fähigkeit verlieren, cast-arrays Mammoth[] zu einem der Basistypen Animal[]ähnlich wie die, die du nicht wirken kannst List<Mammoth> zu List<Animal>. Aber array Kovarianz ist trotzdem abgebrochen, und es gibt bessere alternativen.

Alternativen zum array Kovarianz?

Alle arrays implementieren IList<T>. Wenn die IList<T> - Schnittstelle vorgenommen wurden, in eine richtige kovariante Schnittstelle, dann könnte man die Darsteller alle array - Array<Mammoth> (oder jede Liste für diese Angelegenheit) zu einer IList<Animal>. Dies erfordert jedoch, dass die IList<T> - Schnittstelle umgeschrieben werden entfernen Sie alle Methoden, die möglicherweise Auswirkungen auf das zugrunde liegende array:

interface IList<out T> : ICollection<T>
{
    T this[int index] { get; }
    int IndexOf(object value);
}

interface ICollection<out T> : IEnumerable<T>
{
    int Count { get; }
    bool Contains(object value);
}

(Beachten Sie, dass die Typen der Parameter, input-Positionen nicht T wie dieser brechen würde Kovarianz. Allerdings object ist gut genug für Contains und IndexOfwer würde nur zurück false wenn übergeben ein Objekt einen falschen Typ. Und Sammlungen implementieren dieser Schnittstellen können eigene generische IndexOf(T value) und Contains(T value).)

Dann könnte man dies tun:

Array<Mammoth> mammoths = new Array<Mammoth>(10);
IList<Animals> animals = mammoths;    //Covariant conversion

Gibt es sogar eine kleine Leistungssteigerung, da die Laufzeit würde nicht haben, um zu überprüfen, ob eine zugewiesene Wert-Typ kompatibel mit den tatsächlichen Typ der array-Elemente bei der Einstellung der Wert ein element eines Arrays.

Meinen stab an es

Ich nahm einen Stich an, wie so eine Array<T> Art funktionieren würde, wäre es in C# implementiert und .NETZ, kombiniert mit der realen kovariante IList<T> und ICollection<T> - Schnittstellen, die oben beschrieben und es funktioniert ganz gut. Ich habe auch die invariante IMutableList<T> und IMutableCollection<T> Schnittstellen zur Bereitstellung der mutation Methoden, die meine neue IList<T> und ICollection<T> Schnittstellen fehlen.

Baute ich eine einfache Sammlung Bibliothek um ihn herum, und Sie können laden Sie den Quellcode und die kompilierte binaries von BitBucketoder installieren Sie das NuGet-Paket:

M42.Kollektionen – Spezialisierte Sammlungen mit mehr Funktionalität, Funktionen und Benutzerfreundlichkeit als die eingebaute .NET collection-Klassen.

¹) Ein array T[].Net 4.5, implementiert durch die in der Basisklasse Array: ICloneableIListICollectionIEnumerableIStructuralComparableIStructuralEquatable; und lautlos durch die Laufzeit: IList<T>ICollection<T>IEnumerable<T>IReadOnlyList<T>und IReadOnlyCollection<T>.

InformationsquelleAutor der Antwort Virtlink

[Update, neue Erkenntnisse, es fühlte, dass etwas fehlte bis jetzt]

Bezug auf die frühere Antwort:

• Arrays sind covariant wie andere Arten sein kann. Sie implementieren können, Dinge wie " object[] foo = new string[5];' mit Kovarianz, also das ist nicht der Grund.
• Kompatibilität ist wahrscheinlich der Grund für die nicht zu überdenken, das design, aber ich argumentieren, das ist auch nicht die richtige Antwort.

Aber der andere Grund, warum ich denken kann, ist da ein array die 'Basis-Typ' für eine lineare Reihe von Elementen im Speicher. Ich habe darüber nachgedacht, mit Array<T>, die ist, wo Sie vielleicht auch Fragen, warum T ist ein Objekt, und warum sich dieses "Objekt" überhaupt existiert? In diesem Szenario T[] nur, was ich als eine andere syntax für Array<T> die kovariante mit Array. Da die Typen auch tatsächlich unterscheiden, halte ich das in beiden Fällen ähnlich.

Beachten Sie, dass sowohl ein basic-Objekt und ein basic-Arrays sind nicht Voraussetzung für eine OO Sprache. C++ ist das perfekte Beispiel dafür. Der Nachteil der nicht mit einem basic-Typ für diese grundlegenden Konstrukte nicht in der Lage, die Arbeit mit arrays oder Objekte mit der spiegelung. Für Objekte, die Sie verwendet, um zu machen, Foo Dinge, die macht ein 'Objekt' fühlen sich natürlich an. In der Realität, nicht mit einem array-Basis-Klasse macht es ebenso unmöglich, das zu tun Foo -- die nicht so Häufig verwendet werden, aber ebenso wichtig für das Paradigma.

Daher, dass C# ohne eine Array-base-Typ, aber mit dem Reichtum-runtime-Typen (insbesondere der reflektion), ist IMO unmöglich.

Also mehr in die details...

Wo sind arrays verwendet und warum sind Sie arrays

Dass eine einfache Art für etwas so grundlegend wie ein array verwendet wird, für eine Menge Dinge, und das mit gutem Grund:

• Einfache arrays

Na ja, wir wussten bereits, dass Menschen T[] wie Sie es verwenden List<T>. Beide implementieren einen gemeinsamen Satz von Schnittstellen, um genau zu sein: IList<T>ICollection<T>IEnumerable<T>IListICollection und IEnumerable.

Können Sie ganz einfach ein Array erstellen, wenn Sie wissen das. Wir alle wissen auch, dass dies wahr ist, und es ist nicht aufregend, so bewegen wir uns auf...

• Erstellen von Sammlungen.

Wenn Sie Graben sich in die Liste am Ende hast du ein Array schließlich - um genau zu sein: ein T[] array.

So, warum ist das? Während Sie haben könnte verwendet einen Zeiger-Struktur (LinkedList), es ist einfach nicht das gleiche. Listen sind kontinuierliche Blöcke von Speicher und Holen Sie sich Ihre Geschwindigkeit, indem Sie einen kontinuierlichen Speicherblock. Es gibt eine Menge von Gründen, aber einfach ausgedrückt: Verarbeitung von endlos-Speicher ist die Schnellste Art der Verarbeitung-Speicher - es gibt auch Anweisungen für die, die in Ihrer CPU, die schneller ist.

Einem aufmerksamen Leser verweist auf die Tatsache, dass Sie brauchen nicht ein array, sondern einen kontinuierlichen block von Elementen des Typs 'T' , IL versteht und verarbeiten kann. In anderen Worten, Sie könnte loswerden die Array-Typ, hier, so lange wie Sie sicherstellen, dass es gibt eine andere Art, die verwendet werden können, die von IL, das gleiche zu tun.

Beachten Sie, dass es Wert und Klasse Typen. Um weiterhin die bestmögliche Leistung, die Sie benötigen, speichern Sie Sie in Ihrem block, wie-wie... aber für den Lotsen ist es einfach eine Voraussetzung.

• Marshalling.

Marshalling verwendet grundlegende Typen, alle Sprachen zu vereinbaren, um zu kommunizieren. Diese Grundtypen sind Dinge wie byte, int, float, Zeiger... und array. Vor allem ist der Weg arrays sind in C/C++, das ist so:

for (Foo *foo = beginArray; foo != endArray; ++foo) 
{
    //use *foo -> which is the element in the array of Foo
}

Grundsätzlich das setzt einen Zeiger auf den Beginn des array und inkrementiert den Zeiger (mit sizeof(Foo) bytes), bis er das Ende des Arrays. Das element wird abgerufen *foo - was bekommt das element des pointer 'foo' gerichtet ist.

Beachten Sie wieder, dass es Werttypen und Referenztypen. Sie wirklich nicht wollen, eine MyArray, die einfach speichert alles boxed als ein Objekt. Die Umsetzung MyArray gerade eine Hölle von viel mehr tricky.

Etwas sorgfältiger Leser kann auf die Tatsache, dass Sie hier nicht wirklich brauchen, ein array hier, das ist wahr. Sie brauchen eine kontinuierliche-block-Elemente mit dem Typ Foo - und wenn es einen Wert geben, es muss gespeichert werden, in den block, wie die (byte-Darstellung) Wert Typ.

• Multi-dimensional arrays

So mehr... und Was ist mit multi-Dimensionalität? Anscheinend die Regeln sind nicht so schwarz und weiß, weil wir plötzlich nicht mehr alle base-Klassen mehr:

int[,] foo2 = new int[2, 3];
foreach (var type in foo2.GetType().GetInterfaces())
{
    Console.WriteLine("{0}", type.ToString());
}

Starker Typ ging einfach aus dem Fenster, und Sie am Ende mit collection-Typen IListICollection und IEnumerable. Hey, wie sollen wir die Größe dann? Bei Verwendung der Array-Basis-Klasse, konnten wir verwendet haben:

Array array = foo2;
Console.WriteLine("Length = {0},{1}", array.GetLength(0), array.GetLength(1));

... aber wenn wir uns die alternativen wie IList gibt es keine Entsprechung. Wie lösen wir diese? Sollte die Einführung einer IList<int, int> hier? Dies ist sicherlich falsch, weil das basic-Typ ist nur int. Was IMultiDimentionalList<int>? Wir können das nicht, und füllen Sie ihn mit den Methoden, die derzeit im Array.

• Arrays eine Feste Größe haben

Haben Sie bemerkt, dass es spezielle Aufrufe für die Neuzuweisung von arrays? Das hat alles zu tun mit memory-management: arrays sind so low-level, dass Sie nicht verstehen, was Wachstum oder Schrumpfung sind. In C würden Sie 'malloc' und 'realloc' für diese, und Sie wirklich umsetzen sollten, Ihre eigenen 'malloc' und 'realloc' zu verstehen, warum genau mit festen Größen ist wichtig für alle Dinge, die Sie direkt zuweisen.

Wenn man es betrachtet, es gibt nur ein paar Dinge, die uns zugeteilt, die in einer "festen" Größen: arrays, alle grundlegenden Datentypen, Zeigern und Klassen. Offenbar haben wir handle-arrays unterschiedlich, genau wie wir behandeln grundlegende Typen unterschiedlich.

Einen Seite ein Hinweis über die Art der Sicherheit

Warum also müssen diese alle diese 'access point' Schnittstellen in den ersten Platz?

Die besten Praktiken in allen Fällen ist es, den Nutzern eine sichere Typ-point-of-access. Dies kann illustriert durch den Vergleich von code wie dieser:

array.GetType().GetMethod("GetLength").Invoke(array, 0); //don't...

code wie dieser:

((Array)someArray).GetLength(0); //do!

Geben Sicherheit damit Sie schlampig bei der Programmierung. Wenn richtig eingesetzt, wird der compiler den Fehler zu finden, wenn Sie, statt zu finden, die out-run-Zeit. Ich kann nicht genug betonen, wie wichtig dies ist - nach allem, wird Ihr code kann nicht aufgerufen werden in einem test-Fall zu sein, während der compiler immer es zu bewerten!

Setzen Sie alle zusammen

Also... sagen wir es alle zusammen. Wir wollen:

• Eine stark typisierte block von Daten
• Hat seine Daten kontinuierlich
• IL-Unterstützung, um sicherzustellen, können wir mit der kühlen CPU-Anweisungen, die machen es zu Blutungen schnell
• Eine gemeinsame Schnittstelle macht die gesamte Funktionalität
• Art Sicherheit
• Multi-Dimensionalität
• Wir wollen Werttypen gespeichert werden, die als Wert-Typen
• Und die gleichen Rangierungen Struktur wie jede andere Sprache gibt
• Und eine Feste Größe, denn das macht die Speicherzuordnung einfacher

Das ist schon ein bisschen low-level-Anforderungen für jede Sammlung... es erfordert Speicher organisiert werden, in einer bestimmten Art und Weise sowie Umstellung auf IL/CPU... ich würde sagen, es ist ein guter Grund, es gilt als eine grundlegende Art.

InformationsquelleAutor der Antwort atlaste

Ist wie jeder sagt - original Array ist nicht-generisch, weil es keine Generika, wenn es kam in die Existenz in v1. Spekulationen unter...

Machen "Array" generische (was würde nun Sinn machen), können Sie entweder

1. bleiben die bestehenden Array und fügen Sie generische version. Das ist schön, aber die meisten Verwendungen von "Array" einzubeziehen, es wächst im Laufe der Zeit und ist es wahrscheinlich, dass eine bessere Umsetzung des gleichen Konzepts List<T> umgesetzt wurde, statt. An dieser Stelle hinzufügen von generischen version von "sequenzielle Liste von Elementen, die nicht wachsen" sieht nicht sehr Ansprechend.

2. entfernen Sie nicht generic Array und ersetzen Sie durch generische Array<T> Umsetzung mit der gleichen Schnittstelle. Jetzt haben Sie, um kompilierten code für ältere Versionen der Arbeit mit dem neuen Typ anstelle der bestehenden Array geben. Zwar wäre es möglich (auch wahrscheinlich schwer) für framework-code zu unterstützen, wie migration, es gibt immer eine Menge code geschrieben von anderen Menschen.

   Als Array ist sehr basic Typ so ziemlich jedes Stück von bestehenden code (enthält benutzerdefinierte code mit Reflexion und marshalling mit native code und COM) verwendet. Als Ergebnis der Preis noch so kleinen Inkompatibilität zwischen den Versionen (1.x -> 2.x von .Net Framework) sehr hoch wären.

Also als Ergebnis Array Art ist es für immer bleiben. Wir haben jetzt List<T> als generische äquivalent verwendet werden.

InformationsquelleAutor der Antwort Alexei Levenkov

Vielleicht bin ich etwas fehlt, aber es sei denn, der array-Instanz, angeheuert oder verwendet als eine ICollection, IEnumerable, etc.. dann musst du nicht alles gewinnen, mit einer Reihe von T.

Arrays sind schnell und sind bereits typsicher ist und nicht entstehen boxing/unboxing overhead.

InformationsquelleAutor der Antwort user1758003