Übersicht über das allgemeine Typsystem

Artikel
08/20/2008

Aktualisiert: November 2007

Die in diesem Abschnitt erörterten Konzepte und Begriffsdefinitionen sollen Ihnen helfen, die von Ihnen verwendete Sprachimplementierung des allgemeinen Typsystems zu verstehen und damit zu arbeiten.

Typklassifizierung

Das allgemeine Typsystem unterstützt zwei grundlegende Kategorien von Typen, die jeweils in weitere Unterkategorien gegliedert sind:

Werttypen

Werttypen schließen ihre Daten direkt ein; Instanzen von Werttypen werden entweder auf dem Stapel oder inline in einer Struktur zugewiesen. Werttypen können integriert (durch die Laufzeit implementiert) oder benutzerdefiniert sein bzw. in Form von Enumerationen auftreten. Eine Liste integrierter Werttypen finden Sie in der .NET Framework-Klassenbibliothek.
Verweistypen

In Verweistypen wird ein Verweis auf die Speicheradresse des Werts gespeichert; diese Typen werden auf dem Heap zugewiesen. Verweistypen können selbstbeschreibende Typen, Zeigertypen oder Schnittstellentypen sein. Der Typ eines Verweistyps kann anhand der Werte selbstbeschreibender Typen bestimmt werden. Selbstbeschreibende Typen sind weiter in Arrays und Klassentypen untergliedert. Klassentypen werden aus benutzerdefinierten Klassen, geschachtelten Werttypen und Delegaten gebildet.

Variablen, die Werttypen darstellen, verfügen jeweils über eigene Datenkopien. Daher haben auf eine Variable angewendete Operationen keine Auswirkungen auf andere Variablen. Variablen, die Verweistypen darstellen, können auf dasselbe Objekt verweisen. Daher können auf eine Variable angewendete Operationen ein Objekt beeinflussen, auf das von einer anderen Variablen verwiesen wird.

Alle Typen werden vom System.Object-Basistyp abgeleitet.

Durch das folgende Beispiel wird der Unterschied zwischen Verweistypen und Werttypen veranschaulicht.

Class Class1
    Public Value As Integer = 0
End Class 'Class1

Class Test
    
    Shared Sub Main()
        Dim val1 As Integer = 0
        Dim val2 As Integer = val1
        val2 = 123
        Dim ref1 As New Class1()
        Dim ref2 As Class1 = ref1
        ref2.Value = 123
        Console.WriteLine("Values: {0}, {1}", val1, val2)
        Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value)
    End Sub 'Main
End Class 'Test

using System;
class Class1
{
public int Value = 0;
}
class Test
{
    static void Main() {
        int val1 = 0;
        int val2 = val1;
        val2 = 123;
        Class1 ref1 = new Class1();
        Class1 ref2 = ref1;
        ref2.Value = 123;
        Console.WriteLine("Values: {0}, {1}", val1, val2);
        Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
    }
}

Dieses Programm gibt folgendes Ergebnis aus:

Values: 0, 123
Refs: 123, 123

Anhand des folgenden Diagramms werden die Beziehungen zwischen den verschiedenen Typen erläutert. Beachten Sie, dass Typinstanzen einfache Werttypen oder selbstbeschreibende Typen sein können, und zwar selbst dann, wenn sie Unterkategorien dieser Typen darstellen.

Typklassifizierung

Allgemeines Typsystem

Weitere Informationen zu den einzelnen Typen finden Sie unter Werttypen, Enumerationen, Klassen, Delegaten, Arrays, Schnittstellen und Zeiger.

Werte und Objekte

Werte sind Binärdarstellungen von Daten, und Typen bieten eine Möglichkeit, diese Daten zu interpretieren. Ein Werttyp wird direkt als Binärdarstellung der typeigenen Daten gespeichert. Der Wert eines Verweistyps entspricht dem Speicherort der Bitsequenz, die die Daten des Typs darstellt.

Jeder Wert verfügt über einen exakten Typ, durch den seine Darstellung sowie die für den Wert definierten Operationen vollständig festgelegt werden. Werte von selbstbeschreibenden Typen werden Objekte genannt. Während der Typ eines Objekts immer genau bestimmt werden kann, indem Sie seinen Wert untersuchen, ist dies bei einem Wert- oder Zeigertyp nicht möglich. Ein Wert kann über mehrere Typen verfügen. Der Wert eines Typs, der eine Schnittstelle implementiert, ist gleichzeitig ein Wert dieses Schnittstellentyps. Dementsprechend ist der Wert eines Typs, der von einem Basistyp abgeleitet wird, auch ein Wert dieses Basistyps.

Typen und Assemblys

Die Common Language Runtime verwendet Assemblys, um Typen aufzufinden und zu laden. Das Assemblymanifest enthält Informationen, die von der Common Language Runtime verwendet werden, um alle innerhalb des Gültigkeitsbereichs der Assembly definierten Typverweise aufzulösen.

Ein Typname in der Laufzeit verfügt über zwei logische Bestandteile: den Assemblynamen und den Namen des Typs innerhalb der Assembly. Zwei Typen, die über denselben Namen verfügen, jedoch in verschiedenen Assemblys definiert sind, gelten als zwei unterschiedliche Typen.

Assemblys gewährleisten Konsistenz zwischen dem Namensgültigkeitsbereich, in den der Entwickler Einsicht hat, und dem Namensgültigkeitsbereich, der für das Laufzeitsystem von Bedeutung ist. Typen werden von Entwicklern im Kontext einer Assembly erstellt. Durch den Inhalt der von einem Entwickler programmierten Assembly wird der Gültigkeitsbereich von Namen festgelegt, die zur Laufzeit verfügbar sind.

Typen und Namespaces

Auf die Laufzeitumgebung bezogen, ist ein Namespace lediglich eine Auflistung von Typnamen. Bestimmte Programmiersprachen weisen möglicherweise Konstrukte und eine entsprechende Syntax auf, die den Entwickler dabei unterstützen, Typen logisch zu gruppieren. Diese Konstrukte werden bei der Typbindung jedoch nicht von der Laufzeit verwendet. Daher ist sowohl die Object-Klasse als auch die String-Klasse Teil des System-Namespace. Die Laufzeit erkennt jedoch nur die vollständigen Namen der Typen, die System.Object bzw. System.String angehören.

Sie können eine einzelne Assembly erstellen, durch die Typen bereitgestellt werden, die anscheinend aus zwei unterschiedlichen hierarchischen Namespaces stammen, z. B. System.Collections und System.Windows.Forms. Außerdem können Sie zwei Assemblys erstellen, die beide Typen exportieren und in deren Namen MyDll.MyClass enthalten ist.

Falls Sie ein Tool erstellen, um die Zugehörigkeit von Typen in einer Assembly zu einem hierarchischen Namespace aufzuzeigen, müssen die Typen in einer Assembly oder Gruppe von dem Tool aufgelistet und die Typnamen analysiert werden, um eine hierarchische Beziehung abzuleiten.