Anonieme typen

Anonieme typen bieden een handige manier om een set alleen-lezeneigenschappen in te kapselen in één object zonder dat u eerst expliciet een type hoeft te definiëren. De typenaam wordt gegenereerd door de compiler en is niet beschikbaar op broncodeniveau. Het type van elke eigenschap wordt afgeleid door de compiler.

U maakt anonieme typen door de new operator samen met een object-initialisatiefunctie te gebruiken. Zie Initializers voor objecten en verzamelingen voor meer informatie over object-initialisatiefuncties.

In het volgende voorbeeld ziet u een anoniem type dat is geïnitialiseerd met twee eigenschappen met de naam Amount en Message.

var v = new { Amount = 108, Message = "Hello" };

// Rest the mouse pointer over v.Amount and v.Message in the following
// statement to verify that their inferred types are int and string.
Console.WriteLine(v.Amount + v.Message);

Anonieme typen worden doorgaans gebruikt in de select component van een query-expressie om een subset van de eigenschappen van elk object in de bronreeks te retourneren. Zie LINQ in C# voor meer informatie over query's.

Anonieme typen bevatten een of meer openbare eigenschappen met het kenmerk Alleen-lezen. Er zijn geen andere soorten klasseleden, zoals methoden of gebeurtenissen, geldig. De expressie die wordt gebruikt om een eigenschap te initialiseren, kan geen anonieme functie of een aanwijzertype zijn null.

Het meest voorkomende scenario is het initialiseren van een anoniem type met eigenschappen van een ander type. In het volgende voorbeeld wordt ervan uitgegaan dat er een klasse bestaat met de naam Product. Klasse Product bevat Color en Price eigenschappen, samen met andere eigenschappen waarin u niet geïnteresseerd bent. Variabele products is een verzameling Product objecten. De declaratie van het anonieme type begint met het new trefwoord. De declaratie initialiseert een nieuw type dat slechts twee eigenschappen van Product. Als u anonieme typen gebruikt, wordt een kleinere hoeveelheid gegevens geretourneerd in de query.

Als u geen lidnamen opgeeft in het anonieme type, geeft de compiler de anonieme typeleden dezelfde naam als de eigenschap die wordt gebruikt om ze te initialiseren. U geeft een naam op voor een eigenschap die wordt geïnitialiseerd met een expressie, zoals wordt weergegeven in het vorige voorbeeld. In het volgende voorbeeld zijn Color de namen van de eigenschappen van het anonieme type en Price.

var productQuery =
    from prod in products
    select new { prod.Color, prod.Price };

foreach (var v in productQuery)
{
    Console.WriteLine("Color={0}, Price={1}", v.Color, v.Price);
}

Tip

U kunt .NET-stijlregel IDE0037 gebruiken om af te dwingen of afgeleid of expliciete ledennamen de voorkeur hebben.

Het is ook mogelijk om een veld te definiëren op object van een ander type: klasse, struct of zelfs een ander anoniem type. Dit wordt gedaan met behulp van de variabele die dit object bevat, net zoals in het volgende voorbeeld, waarbij twee anonieme typen worden gemaakt met behulp van reeds geïnstantieerde door de gebruiker gedefinieerde typen. In beide gevallen is het product veld in het anonieme type shipment en shipmentWithBonus van het type Product dat het standaardwaarden van elk veld bevat. En het bonus veld is van het anonieme type dat door de compiler is gemaakt.

var product = new Product();
var bonus = new { note = "You won!" };
var shipment = new { address = "Nowhere St.", product };
var shipmentWithBonus = new { address = "Somewhere St.", product, bonus };

Wanneer u een anoniem type gebruikt om een variabele te initialiseren, declareert u de variabele doorgaans als een impliciet getypte lokale variabele met behulp van var. De typenaam kan niet worden opgegeven in de variabeledeclaratie omdat alleen de compiler toegang heeft tot de onderliggende naam van het anonieme type. Zie Impliciet getypte lokale variabelen voor meer informatie over.var

U kunt een matrix met anoniem getypte elementen maken door een impliciet getypte lokale variabele en een impliciet getypte matrix te combineren, zoals wordt weergegeven in het volgende voorbeeld.

var anonArray = new[] { new { name = "apple", diam = 4 }, new { name = "grape", diam = 1 }};

Anonieme typen zijn class typen die rechtstreeks zijn afgeleid van object, en die niet kunnen worden omgezet in elk type, behalve object. De compiler biedt een naam voor elk anoniem type, hoewel uw toepassing er geen toegang toe heeft. Vanuit het perspectief van de algemene taalruntime is een anoniem type niet anders dan elk ander referentietype.

Als twee of meer anonieme object initializers in een assembly een reeks eigenschappen opgeven die zich in dezelfde volgorde bevinden en dezelfde namen en typen hebben, behandelt de compiler de objecten als exemplaren van hetzelfde type. Ze delen dezelfde door compiler gegenereerde typegegevens.

Anonieme typen ondersteunen niet-destructieve mutatie in de vorm van expressies. Hiermee kunt u een nieuw exemplaar van een anoniem type maken waarbij een of meer eigenschappen nieuwe waarden hebben:

var apple = new { Item = "apples", Price = 1.35 };
var onSale = apple with { Price = 0.79 };
Console.WriteLine(apple);
Console.WriteLine(onSale);

U kunt geen veld, een eigenschap, een gebeurtenis of het retourtype van een methode declareren als een anoniem type. Op dezelfde manier kunt u geen formele parameter van een methode, eigenschap, constructor of indexeerfunctie declareren als een anoniem type. Als u een anoniem type of een verzameling wilt doorgeven die anonieme typen bevat, kunt u als argument voor een methode de parameter declareren als type object. Het gebruik object voor anonieme typen verslaat echter het doel van sterk typen. Als u queryresultaten moet opslaan of deze buiten de methodegrens moet doorgeven, kunt u overwegen een gewone benoemde struct of klasse te gebruiken in plaats van een anoniem type.

Omdat de Equals en GetHashCode methoden voor anonieme typen worden gedefinieerd in termen van de Equals en GetHashCode methoden van de eigenschappen, zijn twee exemplaren van hetzelfde anonieme type alleen gelijk als alle eigenschappen gelijk zijn.

Notitie

Het toegankelijkheidsniveau van een anoniem type is internal, waardoor twee anonieme typen die in verschillende assembly's zijn gedefinieerd, niet van hetzelfde type zijn. Daarom kunnen exemplaren van anonieme typen niet gelijk zijn aan elkaar wanneer ze zijn gedefinieerd in verschillende assembly's, zelfs niet wanneer alle eigenschappen gelijk zijn.

Anonieme typen overschrijven de ToString methode, waarbij de naam en ToString uitvoer van elke eigenschap tussen accolades worden samengevoegd.

var v = new { Title = "Hello", Age = 24 };

Console.WriteLine(v.ToString()); // "{ Title = Hello, Age = 24 }"