Object initializers: Benoemde en anonieme typen (Visual Basic)

Artikel
03/12/2024

Met object-initialisatiefuncties kunt u eigenschappen voor een complex object opgeven met behulp van één expressie. Ze kunnen worden gebruikt om instanties van benoemde typen en anonieme typen te maken.

Declaraties

Declaraties van benoemde en anonieme typen kunnen er bijna identiek uitzien, maar hun effecten zijn niet hetzelfde. Elke categorie heeft eigen mogelijkheden en beperkingen. In het volgende voorbeeld ziet u een handige manier om een exemplaar van een benoemde klasse Customerte declareren en initialiseren met behulp van een object initialisatielijst. U ziet dat de naam van de klasse na het trefwoord Newis opgegeven.

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

Een anoniem type heeft geen bruikbare naam. Daarom kan een instantie van een anoniem type geen klassenaam bevatten.

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

De vereisten en resultaten van de twee declaraties zijn niet hetzelfde. Customer Een namedCustklasse met een Name eigenschap moet al bestaan en de declaratie maakt een exemplaar van die klasse. De anonymousCustcompiler definieert een nieuwe klasse met één eigenschap, een tekenreeks met de naam Nameen maakt een nieuw exemplaar van die klasse.

Benoemde typen

Object-initialisatiefuncties bieden een eenvoudige manier om de constructor van een type aan te roepen en vervolgens de waarden van sommige of alle eigenschappen in één instructie in te stellen. De compiler roept de juiste constructor aan voor de instructie: de parameterloze constructor als er geen argumenten worden weergegeven of een geparameteriseerde constructor als een of meer argumenten worden verzonden. Daarna worden de opgegeven eigenschappen geïnitialiseerd in de volgorde waarin ze worden weergegeven in de initialisatielijst.

Elke initialisatie in de initialisatielijst bestaat uit de toewijzing van een initiële waarde aan een lid van de klasse. De namen en gegevenstypen van de leden worden bepaald wanneer de klasse wordt gedefinieerd. In de volgende voorbeelden moet de Customer klasse bestaan en moeten leden hebben met de naam Name en City die tekenreekswaarden kunnen accepteren.

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

U kunt ook hetzelfde resultaat verkrijgen met behulp van de volgende code:

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

Elk van deze declaraties is gelijk aan het volgende voorbeeld, waarmee een Customer object wordt gemaakt met behulp van de parameterloze constructor en vervolgens de initiële waarden voor de Name en City eigenschappen worden opgegeven met behulp van een With instructie.

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

Als de Customer klasse een geparameteriseerde constructor bevat waarmee u bijvoorbeeld een waarde Namekunt verzenden, kunt u een Customer object op de volgende manieren declareren en initialiseren:

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

U hoeft niet alle eigenschappen te initialiseren, zoals in de volgende code wordt weergegeven.

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

De initialisatielijst mag echter niet leeg zijn. Niet-geïnitialiseerde eigenschappen behouden hun standaardwaarden.

Type deductie met benoemde typen

U kunt de code voor de declaratie cust1 inkorten door object-initialisatie en deductie van het lokale type te combineren. Hierdoor kunt u de As component weglaten in de variabeledeclaratie. Het gegevenstype van de variabele wordt afgeleid van het type object dat door de toewijzing wordt gemaakt. In het volgende voorbeeld is het type cust6 .Customer

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

Opmerkingen over benoemde typen

Een klasselid kan niet meer dan één keer worden geïnitialiseerd in de lijst met object-initialisatiefuncties. De declaratie van cust7 veroorzaakt een fout.

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

Een lid kan worden gebruikt om zichzelf of een ander veld te initialiseren. Als een lid wordt geopend voordat het is geïnitialiseerd, zoals in de volgende declaratie, cust8wordt de standaardwaarde gebruikt. Houd er rekening mee dat wanneer een declaratie die gebruikmaakt van een object-initialisatiefunctie wordt verwerkt, het eerste wat er gebeurt, is dat de juiste constructor wordt aangeroepen. Daarna worden de afzonderlijke velden in de initialisatielijst geïnitialiseerd. In de volgende voorbeelden wordt de standaardwaarde toegewezen voor Namecust8en wordt er een geïnitialiseerde waarde toegewezen in cust9.
```
Dim cust8 = New Customer With {.Name = .Name & ", President"}
Dim cust9 = New Customer With {.Name = "Toni Poe", 
                               .Title = .Name & ", President"}
```
In het volgende voorbeeld wordt de geparameteriseerde constructor gebruikt van cust3 en cust4 om deze te declareren en te initialiseren cust10 en cust11.
```
Dim cust10 = New Customer("Toni Poe") With {.Name = .Name & ", President"}
' --or--
Dim cust11 As New Customer("Toni Poe") With {.Name = .Name & ", President"}
```

Object-initialisatiefuncties kunnen worden genest. In het volgende voorbeeld AddressClass is een klasse met twee eigenschappen City en Stateheeft de Customer klasse een Address eigenschap die een exemplaar is van AddressClass.

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

De initialisatielijst mag niet leeg zijn.
Het exemplaar dat wordt geïnitialiseerd, kan niet van het type Object zijn.
Klassenleden die worden geïnitialiseerd, kunnen geen gedeelde leden, alleen-lezen leden, constanten of methode-aanroepen zijn.
Klasseleden die worden geïnitialiseerd, kunnen niet worden geïndexeerd of gekwalificeerd. De volgende voorbeelden veroorzaken compilerfouten:

'' Not valid.

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

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

Anonieme typen

Anonieme typen maken gebruik van objectinitiizers om exemplaren te maken van nieuwe typen die u niet expliciet definieert en naam. In plaats daarvan genereert de compiler een type op basis van de eigenschappen die u in de lijst met object-initializers hebt aangewezen. Omdat de naam van het type niet is opgegeven, wordt dit een anoniem type genoemd. Vergelijk bijvoorbeeld de volgende declaratie met de vorige voor cust6.

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

Het enige verschil syntactisch is dat er geen naam wordt opgegeven New voor het gegevenstype. Wat er gebeurt, is echter heel anders. De compiler definieert een nieuw anoniem type met twee eigenschappen Name en Citymaakt er een exemplaar van met de opgegeven waarden. Typedeductie bepaalt de typen en NameCity in het voorbeeld tekenreeksen.

Let op

De naam van het anonieme type wordt gegenereerd door de compiler en kan variëren van compilatie tot compilatie. Uw code mag niet worden gebruikt of vertrouwt op de naam van een anoniem type.

Omdat de naam van het type niet beschikbaar is, kunt u geen As component gebruiken om te declareren cust13. Het type moet worden afgeleid. Zonder late binding te gebruiken, beperkt dit het gebruik van anonieme typen tot lokale variabelen.

Anonieme typen bieden essentiële ondersteuning voor LINQ-query's. Zie Anonieme typen en inleiding tot LINQ in Visual Basic voor meer informatie over het gebruik van anonieme typen in query's .

Opmerkingen over anonieme typen

Normaal gesproken zijn alle of de meeste eigenschappen in een anonieme typedeclaratie belangrijke eigenschappen, die worden aangegeven door het trefwoord Key vóór de naam van de eigenschap te typen.
```
Dim anonymousCust1 = New With {Key .Name = "Hugo Garcia", 
                               Key .City = "Louisville"}
```
Zie Sleutel voor meer informatie over sleuteleigenschappen.
Net als benoemde typen moeten initialisatielijsten voor anonieme typedefinities ten minste één eigenschap declareren.
```
Dim anonymousCust = New With {.Name = "Hugo Garcia"}
```
Wanneer een exemplaar van een anoniem type wordt gedeclareerd, genereert de compiler een overeenkomende anonieme typedefinitie. De namen en gegevenstypen van de eigenschappen worden opgehaald uit de exemplaardeclaratie en worden opgenomen door de compiler in de definitie. De eigenschappen worden vooraf niet benoemd en gedefinieerd, zoals ze zouden zijn voor een benoemd type. Hun typen worden afgeleid. U kunt de gegevenstypen van de eigenschappen niet opgeven met behulp van een As component.
Anonieme typen kunnen ook de namen en waarden van hun eigenschappen op verschillende andere manieren tot stand brengen. Een eigenschap van een anoniem type kan bijvoorbeeld zowel de naam als de waarde van een variabele aannemen, of de naam en waarde van een eigenschap van een ander object.
```
' 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}
```
Zie Instructies voor het definiëren van eigenschappen in anonieme typen voor meer informatie over de opties voor het definiëren van eigenschappen: Eigenschapsnamen en typen afleiden in anonieme typedeclaraties.

Share via