Gewusst wie: Ableiten von Eigenschaftennamen und Typen in Deklarationen von anonymen Typen (Visual Basic)

Artikel
06/08/2015

Anonyme Typen stellen keinen Mechanismus zum direkten Angeben der Datentypen von Eigenschaften bereit. Die Typen aller Eigenschaften werden abgeleitet. Im folgenden Beispiel werden die Typen von Name und Price direkt von den zur Initialisierung verwendeten Werten abgeleitet.

' Variable product is an instance of a simple anonymous type. 
Dim product = New With {Key .Name = "paperclips", .Price = 1.29}

Anonyme Typen können Eigenschaftennamen und Typen auch von anderen Quellen ableiten. In den folgenden Abschnitten wird sowohl eine Liste der Umstände dargestellt, unter denen Ableitung möglich ist, als auch Situationen, in denen sie nicht möglich ist.

Erfolgreiche Ableitung

Anonyme Typen können Eigenschaftennamen und Typen von folgenden Quellen ableiten:

Von Variablennamen. Der anonyme Typ anonProduct hat die beiden Eigenschaften productName und productPrice. Ihre Datentypen sind die der ursprünglichen Variablen, d. h. String und Double.

Dim productName As String = "paperclips" 
Dim productPrice As Double = 1.29
Dim anonProduct = New With {Key productName, Key productPrice}

' To create uppercase variable names for the new properties, 
' assign variables productName and productPrice to uppercase identifiers. 
Dim anonProduct1 = New With {Key .Name = productName, Key .Price = productPrice}

Von Eigenschaften- oder Feldnamen anderer Objekte. Betrachten Sie z. B. ein car-Objekt eines CarClass-Typs, der die Name-Eigenschaft und die ID-Eigenschaft enthält. Um die neue Instanz car1 eines anonymen Typs mit der Name-Eigenschaft und der ID-Eigenschaft zu erstellen, die mit den Werten des car-Objekts initialisiert werden, können Sie folgenden Code schreiben:
```
Dim car1 = New With {Key car.Name, Key car.ID}
```
Die vorherige Deklaration entspricht der längeren Codezeile, die den anonymen Typ car2 definiert.
```
Dim car2 = New With {Key .Name = car.Name, Key .ID = car.ID}
```

Von XML-Membernamen.

Dim books = <Books>
                <Book Author="Jesper Aaberg">
                    Advanced Programming Methods
                </Book>
            </Books>
Dim anon = New With {books...<Book>}

Der resultierende Typ für anon hätte nur die Eigenschaft Book vom Typ IEnumerable(von XElement).

Von einer Funktion, die über keine Parameter verfügt, z. B. SomeFunction in folgendem Beispiel.

Dim sc As New SomeClass

Dim anon1 = New With {Key sc.SomeFunction()}

Die Variable anon2 im folgenden Code ist ein anonymer Typ mit einem Zeichen mit dem Namen First als einziger Eigenschaft. Von diesem Code wird der Buchstabe "E" angezeigt, der von der Funktion First``1 zurückgegeben wird.
```
Dim aString As String = "Example String" 
Dim anon2 = New With {Key aString.First()}
' The variable anon2 has one property, First.
Console.WriteLine(anon2.First)
```

Ableitungsfehler

Die Ableitung von Namen schlägt in vielen Fällen fehl, darunter in den folgenden:

Die Ableitung erfolgt über den Aufruf einer Methode, eines Konstruktors oder einer parametrisierten Eigenschaft, die Argumente benötigt. Die vorhergehende Deklaration von anon1 schlägt fehl, wenn someFunction über ein oder mehrere Argumente verfügt.

' Not valid.

' Dim anon3 = New With {Key sc.someFunction(someArg)}

Durch Zuweisung zu einem neuen Eigenschaftennamen kann das Problem gelöst werden.

' Valid.

Dim anon4 = New With {Key .FunResult = sc.someFunction(someArg)}

Die Ableitung erfolgt von einem komplexen Ausdruck.

Dim aString As String = "Act "
' Not valid.
' Dim label = New With {Key aString & "IV"}

Der Fehler kann behoben werden, indem das Ergebnis des Ausdrucks einem Eigenschaftennamen zugewiesen wird.

' Valid. 
Dim label1 = New With {Key .someLabel = aString & "IV"}

Die Ableitung für mehrere Eigenschaften erzeugt zwei oder mehr Eigenschaften mit dem gleichen Namen. Ausgehend von Deklarationen in vorhergehenden Beispielen können product.Name und car1.Name nicht gleichzeitig als Eigenschaften desselben anonymen Typs aufgelistet werden. Der Grund dafür ist, dass für beide der abgeleitete Bezeichner Name wäre.

' Not valid.

' Dim anon5 = New With {Key product.Name, Key car1.Name}

Das Problem kann gelöst werden, indem die Werte unterschiedlichen Eigenschaftennamen zugewiesen werden.
```
' Valid. 
Dim anon6 = New With {Key .ProductName = product.Name, Key .CarName = car1.Name}
```
Beachten Sie, dass Unterschiede in der Groß- und Kleinschreibung zwei Namen nicht unterschiedlich machen.

Dim price = 0

' Not valid, because Price and price are the same name.

' Dim anon7 = New With {Key product.Price, Key price}
Der ursprüngliche Typ und Wert einer Eigenschaft sind von einer anderen Eigenschaft abhängig, die noch nicht festgelegt wurde. Zum Beispiel ist .IDName = .LastName in der Deklaration eines anonymen Typs nicht zulässig, wenn .LastName noch nicht initialisiert wurde.

' Not valid.

' Dim anon8 = New With {Key .IDName = .LastName, Key .LastName = "Jones"}

In diesem Beispiel kann das Problem behoben werden, indem die Reihenfolge, in der die Eigenschaften deklariert werden, umgekehrt wird.
```
' Valid. 
Dim anon9 = New With {Key .LastName = "Jones", Key .IDName = .LastName}
```
Ein Eigenschaftennamen eines anonymen Typs ist derselbe, wie der Name eines Members von Object. Zum Beispiel schlägt die folgende Deklaration fehl, da Equals eine Methode von Object ist.

' Not valid.

' Dim relationsLabels1 = New With {Key .Equals = "equals", Key .Greater = _

' "greater than", Key .Less = "less than"}

Sie können das Problem beheben, indem Sie den Eigenschaftennamen ändern:
```
' Valid  
Dim relationsLabels2 = New With {Key .EqualString = "equals",
                                 Key .GreaterString = "greater than",
                                 Key .LessString = "less than"}
```