Share via

Anonieme typen (Visual Basic)

  • Artikel

Visual Basic ondersteunt anonieme typen, waarmee u objecten kunt maken zonder een klassedefinitie voor het gegevenstype te schrijven. In plaats daarvan genereert de compiler een klasse voor u. De klasse heeft geen bruikbare naam, neemt rechtstreeks van Objecten bevat de eigenschappen die u opgeeft bij het declareren van het object. Omdat de naam van het gegevenstype niet is opgegeven, wordt dit een anoniem type genoemd.

In het volgende voorbeeld worden variabelen product gede declareren en gemaakt als een exemplaar van een anoniem type met twee eigenschappen, Name en Price.

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

Een query-expressie maakt gebruik van anonieme typen om kolommen met gegevens te combineren die door een query zijn geselecteerd. U kunt het type van het resultaat niet vooraf definiëren, omdat u niet kunt voorspellen welke kolommen een bepaalde query kan selecteren. Met anonieme typen kunt u een query schrijven die een willekeurig aantal kolommen selecteert, in elke volgorde. De compiler maakt een gegevenstype dat overeenkomt met de opgegeven eigenschappen en de opgegeven volgorde.

In de volgende voorbeelden products ziet u een lijst met productobjecten, die elk veel eigenschappen hebben. De variabele namePriceQuery bevat de definitie van een query die, wanneer deze wordt uitgevoerd, een verzameling exemplaren retourneert van een anoniem type met twee eigenschappen en NamePrice.

Dim namePriceQuery = From prod In products
                     Select prod.Name, prod.Price

De variabele nameQuantityQuery bevat de definitie van een query die, wanneer deze wordt uitgevoerd, een verzameling exemplaren retourneert van een anoniem type met twee eigenschappen en NameOnHand.

Dim nameQuantityQuery = From prod In products
                        Select prod.Name, prod.OnHand

Zie Anonieme typedefinitie voor meer informatie over de code die door de compiler is gemaakt voor een anoniem type.

Let op

De naam van het anonieme type wordt gegenereerd 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 kan veranderen wanneer een project opnieuw wordt gecompileerd.

Een anoniem type declareren

De declaratie van een exemplaar van een anoniem type maakt gebruik van een initialisatielijst om de eigenschappen van het type op te geven. U kunt alleen eigenschappen opgeven wanneer u een anoniem type declareert, niet andere klasse-elementen, zoals methoden of gebeurtenissen. In het volgende voorbeeld product1 is dit een exemplaar van een anoniem type met twee eigenschappen: Name en Price.

' Variable product1 is an instance of a simple anonymous type.
Dim product1 = New With {.Name = "paperclips", .Price = 1.29}
' -or-
' product2 is an instance of an anonymous type with key properties.
Dim product2 = New With {Key .Name = "paperclips", Key .Price = 1.29}

Als u eigenschappen als sleuteleigenschappen aanwijst, kunt u deze gebruiken om twee anonieme instanties voor gelijkheid te vergelijken. De waarden van sleuteleigenschappen kunnen echter niet worden gewijzigd. Zie de sectie Sleuteleigenschappen verderop in dit onderwerp voor meer informatie.

U ziet dat het declareren van een exemplaar van een anoniem type lijkt op het declareren van een exemplaar van een benoemd type met behulp van een object initializer:

' Variable product3 is an instance of a class named Product.
Dim product3 = New Product With {.Name = "paperclips", .Price = 1.29}

Zie Procedure: Eigenschapsnamen en typen afleiden in anonieme typedeclaraties voor meer informatie over andere manieren om eigenschappen op te geven.

Belangrijke eigenschappen

Sleuteleigenschappen verschillen op verschillende fundamentele manieren van niet-sleuteleigenschappen:

  • Alleen de waarden van sleuteleigenschappen worden vergeleken om te bepalen of twee exemplaren gelijk zijn.

  • De waarden van sleuteleigenschappen zijn alleen-lezen en kunnen niet worden gewijzigd.

  • Alleen sleuteleigenschapswaarden worden opgenomen in het door de compiler gegenereerde hashcode-algoritme voor een anoniem type.

Equality

Exemplaren van anonieme typen kunnen alleen gelijk zijn als ze exemplaren van hetzelfde anonieme type zijn. De compiler behandelt twee exemplaren als exemplaren van hetzelfde type als ze voldoen aan de volgende voorwaarden:

  • Ze worden gedeclareerd in dezelfde assembly.

  • Hun eigenschappen hebben dezelfde namen, dezelfde uitgestelde typen en worden gedeclareerd in dezelfde volgorde. Naamvergelijkingen zijn niet hoofdlettergevoelig.

  • Dezelfde eigenschappen in elk zijn gemarkeerd als sleuteleigenschappen.

  • Ten minste één eigenschap in elke declaratie is een sleuteleigenschap.

Een exemplaar van anonieme typen zonder sleuteleigenschappen is alleen gelijk aan zichzelf.

' prod1 and prod2 have no key values.
Dim prod1 = New With {.Name = "paperclips", .Price = 1.29}
Dim prod2 = New With {.Name = "paperclips", .Price = 1.29}

' The following line displays False, because prod1 and prod2 have no
' key properties.
Console.WriteLine(prod1.Equals(prod2))

' The following statement displays True because prod1 is equal to itself.
Console.WriteLine(prod1.Equals(prod1))

Twee exemplaren van hetzelfde anonieme type zijn gelijk als de waarden van de sleuteleigenschappen gelijk zijn. In de volgende voorbeelden ziet u hoe gelijkheid wordt getest.

Dim prod3 = New With {Key .Name = "paperclips", Key .Price = 1.29}
Dim prod4 = New With {Key .Name = "paperclips", Key .Price = 1.29}
' The following line displays True, because prod3 and prod4 are
' instances of the same anonymous type, and the values of their
' key properties are equal.
Console.WriteLine(prod3.Equals(prod4))

Dim prod5 = New With {Key .Name = "paperclips", Key .Price = 1.29}
Dim prod6 = New With {Key .Name = "paperclips", Key .Price = 1.29,
                      .OnHand = 423}
' The following line displays False, because prod5 and prod6 do not 
' have the same properties.
Console.WriteLine(prod5.Equals(prod6))

Dim prod7 = New With {Key .Name = "paperclips", Key .Price = 1.29,
                      .OnHand = 24}
Dim prod8 = New With {Key .Name = "paperclips", Key .Price = 1.29,
                      .OnHand = 423}
' The following line displays True, because prod7 and prod8 are
' instances of the same anonymous type, and the values of their
' key properties are equal. The equality check does not compare the
' values of the non-key field.
Console.WriteLine(prod7.Equals(prod8))

Alleen-lezen waarden

De waarden van sleuteleigenschappen kunnen niet worden gewijzigd. In het vorige voorbeeld zijn read-onlyde velden en Price velden Name bijvoorbeeldprod8, maar OnHand kunnen worden gewijzigd.

' The following statement will not compile, because Name is a key
' property and its value cannot be changed.
' prod8.Name = "clamps"

' OnHand is not a Key property. Its value can be changed.
prod8.OnHand = 22

Anonieme typen uit query-expressies

Voor query-expressies is niet altijd het maken van anonieme typen vereist. Indien mogelijk gebruiken ze een bestaand type voor het opslaan van de kolomgegevens. Dit gebeurt wanneer de query hele records uit de gegevensbron retourneert of slechts één veld uit elke record. In de volgende codevoorbeelden customers is een verzameling objecten van een Customer klasse. De klasse heeft veel eigenschappen en u kunt een of meer eigenschappen opnemen in het queryresultaat, in elke volgorde. In de eerste twee voorbeelden zijn er geen anonieme typen vereist omdat de query's elementen van benoemde typen selecteren:

  • custs1 bevat een verzameling tekenreeksen, omdat cust.Name dit een tekenreeks is.

    Dim custs1 = From cust In customers
             Select cust.Name

  • custs2 bevat een verzameling Customer objecten, omdat elk element customers een Customer object is en het hele element wordt geselecteerd door de query.

    Dim custs2 = From cust In customers
             Select cust

De juiste benoemde typen zijn echter niet altijd beschikbaar. Misschien wilt u klantnamen en -adressen selecteren voor één doel, klant-id's en locaties voor een andere, en klantnamen, adressen en bestelgeschiedenis voor een derde. Met anonieme typen kunt u elke combinatie van eigenschappen selecteren, in willekeurige volgorde, zonder eerst een nieuw benoemd type te declareren om het resultaat te bewaren. In plaats daarvan maakt de compiler een anoniem type voor elke compilatie van eigenschappen. De volgende query selecteert alleen de naam en het id-nummer van de klant uit elk Customer object in customers. Daarom maakt de compiler een anoniem type dat alleen die twee eigenschappen bevat.

Dim custs3 = From cust In customers
             Select cust.Name, cust.ID

Zowel de namen als de gegevenstypen van de eigenschappen in het anonieme type worden van de argumenten naar Select, cust.Name en cust.ID. De eigenschappen in een anoniem type dat door een query wordt gemaakt, zijn altijd sleuteleigenschappen. Wanneer custs3 wordt uitgevoerd in de volgende For Each lus, is het resultaat een verzameling exemplaren van een anoniem type met twee sleuteleigenschappen en NameID.

For Each selectedCust In custs3
    Console.WriteLine(selectedCust.ID & ": " & selectedCust.Name)
Next

De elementen in de verzameling die worden vertegenwoordigd door custs3 zijn sterk getypt en u kunt IntelliSense gebruiken om door de beschikbare eigenschappen te navigeren en hun typen te controleren.

Zie Inleiding tot LINQ in Visual Basic voor meer informatie.

Bepalen of anonieme typen moeten worden gebruikt

Voordat u een object maakt als exemplaar van een anonieme klasse, moet u overwegen of dit de beste optie is. Als u bijvoorbeeld een tijdelijk object wilt maken dat gerelateerde gegevens bevat en u geen andere velden en methoden nodig hebt die een volledige klasse kan bevatten, is een anoniem type een goede oplossing. Anonieme typen zijn ook handig als u een andere selectie eigenschappen voor elke declaratie wilt of als u de volgorde van de eigenschappen wilt wijzigen. Als uw project echter meerdere objecten bevat die dezelfde eigenschappen hebben, kunt u deze in een vaste volgorde eenvoudiger declareren met behulp van een benoemd type met een klasseconstructor. Met een geschikte constructor is het bijvoorbeeld eenvoudiger om verschillende exemplaren van een Product klasse te declareren dan om verschillende exemplaren van een anoniem type te declareren.

' Declaring instances of a named type.
Dim firstProd1 As New Product("paperclips", 1.29)
Dim secondProd1 As New Product("desklamp", 28.99)
Dim thirdProd1 As New Product("stapler", 5.09)

' Declaring instances of an anonymous type.
Dim firstProd2 = New With {Key .Name = "paperclips", Key .Price = 1.29}
Dim secondProd2 = New With {Key .Name = "desklamp", Key .Price = 28.99}
Dim thirdProd2 = New With {Key .Name = "stapler", Key .Price = 5.09}

Een ander voordeel van benoemde typen is dat de compiler een onbedoelde misting van een eigenschapsnaam kan vangen. In de vorige voorbeelden, firstProd2secondProd2en thirdProd2 zijn bedoeld als exemplaren van hetzelfde anonieme type. Als u echter per ongeluk op een van de volgende manieren zou declareren thirdProd2 , zou het type afwijken van dat van firstProd2 en secondProd2.

' Dim thirdProd2 = New With {Key .Name = "stapler", Key .Price = 5.09}
' Dim thirdProd2 = New With {Key .Name = "stapler", Key .Price = "5.09"}
' Dim thirdProd2 = New With {Key .Name = "stapler", .Price = 5.09}

Belangrijker is dat er beperkingen gelden voor het gebruik van anonieme typen die niet van toepassing zijn op exemplaren van benoemde typen. firstProd2, secondProd2en thirdProd2 zijn exemplaren van hetzelfde anonieme type. De naam voor het gedeelde anonieme type is echter niet beschikbaar en kan niet worden weergegeven waar een typenaam wordt verwacht in uw code. Een anoniem type kan bijvoorbeeld niet worden gebruikt om een methodehandtekening te definiëren, een andere variabele of een ander veld te declareren of in een typedeclaratie. Als gevolg hiervan zijn anonieme typen niet geschikt wanneer u informatie over verschillende methoden moet delen.

Een definitie van een anoniem type

Als reactie op de declaratie van een exemplaar van een anoniem type, maakt de compiler een nieuwe klassedefinitie die de opgegeven eigenschappen bevat.

Als het anonieme type ten minste één sleuteleigenschap bevat, overschrijft de definitie drie leden die zijn overgenomen van Object: Equals, GetHashCodeen ToString. De code die wordt geproduceerd voor het testen van gelijkheid en het bepalen van de hash-codewaarde houdt alleen rekening met de sleuteleigenschappen. Als het anonieme type geen sleuteleigenschappen bevat, wordt alleen ToString overschreven. Expliciet benoemde eigenschappen van een anoniem type kunnen niet conflicteren met deze gegenereerde methoden. Dat wil gezegd, u kunt een eigenschap niet gebruiken .Equals.GetHashCodeof .ToString een naam geven.

Anonieme typedefinities met ten minste één sleuteleigenschap implementeren ook de System.IEquatable<T> interface, waarbij T het type van het anonieme type is.

Zie Anonieme typedefinitie voor meer informatie over de code die is gemaakt door de compiler en de functionaliteit van de overschreven methoden.

Zie ook