Freigeben über

Objektinitialisierer: Benannte und anonyme Typen (Visual Basic)

Mithilfe von Objektinitialisierern können Sie Eigenschaften für ein komplexes Objekt mithilfe eines einzelnen Ausdrucks angeben. Sie können verwendet werden, um Instanzen benannter Typen und anonymer Typen zu erstellen.

Deklarationen

Deklarationen von Instanzen von benannten und anonymen Typen können fast identisch aussehen, aber ihre Auswirkungen sind nicht identisch. Jede Kategorie verfügt über eigene Fähigkeiten und Einschränkungen. Das folgende Beispiel zeigt eine bequeme Möglichkeit zum Deklarieren und Initialisieren einer Instanz einer benannten Klasse Customermithilfe einer Objektinitialisierungsliste. Beachten Sie, dass der Name der Klasse nach dem Schlüsselwort Newangegeben wird.

Dim namedCust = New Customer With {.Name = "Terry Adams"}

Ein anonymer Typ hat keinen verwendbaren Namen. Daher kann eine Instanziierung eines anonymen Typs keinen Klassennamen enthalten.

Dim anonymousCust = New With {.Name = "Hugo Garcia"}

Die Anforderungen und Ergebnisse der beiden Deklarationen sind nicht identisch. Für namedCust muss bereits eine Customer-Klasse existieren, die eine Name-Eigenschaft hat, und die Deklaration erstellt eine Instanz dieser Klasse. Für anonymousCust definiert der Compiler eine neue Klasse, die eine Eigenschaft hat, einen String namens Name, und erstellt eine neue Instanz dieser Klasse.

Benannte Typen

Objektinitialisierer bieten eine einfache Möglichkeit, den Konstruktor eines Typs aufzurufen und dann die Werte einiger oder aller Eigenschaften in einer einzelnen Anweisung festzulegen. Der Compiler ruft den entsprechenden Konstruktor für die Anweisung auf: der parameterlose Konstruktor, wenn keine Argumente angezeigt werden, oder ein parametrisierter Konstruktor, wenn mindestens ein Argument gesendet wird. Danach werden die angegebenen Eigenschaften in der Reihenfolge initialisiert, in der sie in der Initialisierungsliste angezeigt werden.

Jede Initialisierung in der Initialisierungsliste besteht aus der Zuordnung eines Anfangswerts zu einem Element der Klasse. Die Namen und Datentypen der Member werden bestimmt, wenn die Klasse definiert ist. In den folgenden Beispielen muss die Customer-Klasse vorhanden sein und Mitglieder namens Name und City haben, die Zeichenfolgen akzeptieren können.

Dim cust0 As Customer = New Customer With {.Name = "Toni Poe", 
                                           .City = "Louisville"}

Alternativ können Sie dasselbe Ergebnis mit dem folgenden Code abrufen:

Dim cust1 As New Customer With {.Name = "Toni Poe", 
                                .City = "Louisville"}

Jede dieser Deklarationen entspricht dem folgenden Beispiel, das ein Customer Objekt mithilfe des parameterlosen Konstruktors erstellt und dann die Anfangswerte für die Name und City die Eigenschaften mithilfe einer With Anweisung angibt.

Dim cust2 As New Customer()
With cust2
    .Name = "Toni Poe"
    .City = "Louisville"
End With

Wenn die Customer Klasse einen parametrisierten Konstruktor enthält, mit dem Sie z. B. einen Wert Namesenden können, können Sie ein Customer Objekt auch auf folgende Weise deklarieren und initialisieren:

Dim cust3 As Customer = 
    New Customer("Toni Poe") With {.City = "Louisville"}
' --or--
Dim cust4 As New Customer("Toni Poe") With {.City = "Louisville"}

Sie müssen nicht alle Eigenschaften initialisieren, wie der folgende Code zeigt.

Dim cust5 As Customer = New Customer With {.Name = "Toni Poe"}

Die Initialisierungsliste kann jedoch nicht leer sein. Nicht initialisierte Eigenschaften behalten ihre Standardwerte bei.

Typrückschluss mit benannten Typen

Sie können den Code für die Deklaration von cust1 kürzen, indem Sie Objektinitialisierer und lokale Typinferenz kombinieren. Auf diese Weise können Sie die As Klausel in der Variablendeklaration weglassen. Der Datentyp der Variablen wird vom Typ des Objekts abgeleitet, das von der Zuordnung erstellt wird. Im folgenden Beispiel ist der Typ von cust6Customer.

Dim cust6 = New Customer With {.Name = "Toni Poe", 
                               .City = "Louisville"}

Hinweise zu benannten Typen

  • Ein Klassenmember kann nicht mehrmals in der Objektinitialisiererliste initialisiert werden. Die Deklaration von cust7 verursacht einen Fehler.

    '' This code does not compile because Name is initialized twice.
' Dim cust7 = New Customer With {.Name = "Toni Poe", 
'                                .City = "Louisville",
'                                .Name = "Blue Yonder Airlines"}

  • Ein Member kann verwendet werden, um sich selbst oder ein anderes Feld zu initialisieren. Wenn auf ein Element zugegriffen wird, bevor es initialisiert wurde, wie in der folgenden Deklaration für cust8, wird der Standardwert verwendet. Denken Sie daran, dass beim Verarbeiten einer Deklaration, die einen Objektinitialisierer verwendet, zunächst der entsprechende Konstruktor aufgerufen wird. Danach werden die einzelnen Felder in der Initialisierungsliste initialisiert. In den folgenden Beispielen wird der Standardwert von Name auf cust8 zugewiesen, und ein initialisierter Wert wird in cust9 zugewiesen.

    Dim cust8 = New Customer With {.Name = .Name & ", President"}
Dim cust9 = New Customer With {.Name = "Toni Poe", 
                               .Title = .Name & ", President"}

    Im folgenden Beispiel wird der parametrisierte Konstruktor aus cust3 und cust4 verwendet, um cust10 und cust11 zu deklarieren und zu initialisieren.

    Dim cust10 = New Customer("Toni Poe") With {.Name = .Name & ", President"}
' --or--
Dim cust11 As New Customer("Toni Poe") With {.Name = .Name & ", President"}

  • Objektinitialisierer können geschachtelt werden. Im folgenden Beispiel ist AddressClass eine Klasse, die zwei Eigenschaften, City und State, hat, und die Klasse Customer verfügt über eine Eigenschaft Address, die eine Instanz von AddressClass ist.

    Dim cust12 = 
    New Customer With {.Name = "Toni Poe", 
                       .Address = 
                           New AddressClass With {.City = "Louisville", 
                                                  .State = "Kentucky"}}
Console.WriteLine(cust12.Address.State)

  • Die Initialisierungsliste darf nicht leer sein.

  • Die initialisierte Instanz darf nicht vom Typ "Object" sein.

  • Klassenmember, die initialisiert werden, dürfen nicht freigegebene Member, schreibgeschützte Member, Konstanten oder Methodenaufrufe sein.

  • Klassenmember, die initialisiert werden, können nicht indiziert oder qualifiziert werden. Die folgenden Beispiele lösen Compilerfehler aus:

    '' Not valid.

    ' Dim c1 = New Customer With {.OrderNumbers(0) = 148662}

    ' Dim c2 = New Customer with {.Address.City = "Springfield"}

Anonyme Typen

Anonyme Typen verwenden Objektinitialisierer, um Instanzen neuer Typen zu erstellen, die Sie nicht explizit definieren und benennen. Stattdessen generiert der Compiler einen Typ gemäß den Eigenschaften, die Sie in der Objektinitialisierungsliste festlegen. Da der Name des Typs nicht angegeben ist, wird er als anonymer Typ bezeichnet. Vergleichen Sie beispielsweise die folgende Deklaration mit der früheren Deklaration für cust6.

Dim cust13 = New With {.Name = "Toni Poe", 
                       .City = "Louisville"}

Der einzige Unterschied in der Syntax ist, dass nach New für den Datentyp kein Name angegeben wird. Was jedoch passiert, ist ganz anders. Der Compiler definiert einen neuen anonymen Typ mit zwei Eigenschaften Name und Cityerstellt eine Instanz davon mit den angegebenen Werten. Typinference bestimmt die Typen von Name und City im Beispiel als Zeichenfolgen.

Vorsicht

Der Name des anonymen Typs wird vom Compiler generiert und kann von Kompilierung zu Kompilierung variieren. Ihr Code sollte sich nicht auf den Namen eines anonymen Typs verlassen oder diesen verwenden.

Da der Name des Typs nicht verfügbar ist, können Sie keine As Klausel zum Deklarieren cust13verwenden. Der Typ muss abgeleitet werden. Ohne späte Bindung beschränkt dies die Verwendung anonymer Typen auf lokale Variablen.

Anonyme Typen bieten wichtige Unterstützung für LINQ-Abfragen. Weitere Informationen zur Verwendung anonymer Typen in Abfragen finden Sie unter "Anonyme Typen " und "Einführung in LINQ" in Visual Basic.

Hinweise zu anonymen Typen

  • In der Regel sind alle oder die meisten Eigenschaften in einer anonymen Typdeklaration wichtige Eigenschaften, die durch Eingabe des Schlüsselworts Key vor dem Eigenschaftennamen angegeben werden.

    
Dim anonymousCust1 = New With {Key .Name = "Hugo Garcia", 
                               Key .City = "Louisville"}

    Weitere Informationen zu schlüsseleigenschaften finden Sie unter "Key".

  • Wie benannte Typen müssen Initialisierungslisten für anonyme Typdefinitionen mindestens eine Eigenschaft deklarieren.

    Dim anonymousCust = New With {.Name = "Hugo Garcia"}

  • Wenn eine Instanz eines anonymen Typs deklariert wird, generiert der Compiler eine übereinstimmende Definition für anonymen Typ. Die Namen und Datentypen der Eigenschaften stammen aus der Instanzdeklaration und werden vom Compiler in der Definition eingeschlossen. Die Eigenschaften werden nicht im Voraus benannt und definiert, wie es bei einem benannten Typ der Fall wäre. Ihre Typen werden abgeleitet. Sie können die Datentypen der Eigenschaften nicht mithilfe einer As Klausel angeben.

  • Anonyme Typen können auch die Namen und Werte ihrer Eigenschaften auf verschiedene andere Weise festlegen. Beispielsweise kann eine anonyme Typeigenschaft sowohl den Namen als auch den Wert einer Variablen oder den Namen und den Wert einer Eigenschaft eines anderen Objekts verwenden.

    ' Create a variable, Name, and give it an initial value.
Dim Name = "Hugo Garcia"

' Variable anonymousCust2 will have one property, Name, with 
' "Hugo Garcia" as its initial value.
Dim anonymousCust2 = New With {Key Name}

' The next declaration uses a property from namedCust, defined
' in an earlier example. After the declaration, anonymousCust3 will
' have one property, Name, with "Terry Adams" as its value.
Dim anonymousCust3 = New With {Key namedCust.Name}

    Weitere Informationen zu den Optionen zum Definieren von Eigenschaften in anonymen Typen finden Sie unter So ermitteln Sie Eigenschaftsnamen und -typen in Deklarationen anonymer Typen.

Siehe auch