Delen via

Anonieme typen (C#-programmeerhandleiding)

Anonieme typen bieden een handige manier om een set alleen-lezeneigenschappen in één object in te kapselen zonder eerst een benoemd type te definiëren. De compiler genereert een typenaam tijdens het compileren die u niet kunt openen in uw broncode. De compiler bepaalt het type van elke eigenschap.

Maak anonieme typen met behulp van de new operator samen met een object-initialisatiefunctie. In het volgende voorbeeld ziet u een anoniem type dat is geïnitialiseerd met twee eigenschappen en NameAge:

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"{person.Name} is {person.Age} years old.");
// Output:
// Alice is 30 years old.

Namen van afgeleide eigenschappen

U kunt eigenschapsnamen expliciet opgeven met behulp van de Name = value syntaxis. Wanneer u een anoniem type initialiseert met een variabele of toegangsexpressie voor leden, wordt de eigenschapsnaam van die expressie afgeleid door de compiler:

string productName = "Laptop";
decimal price = 999.99m;
var product = new { productName, price };
Console.WriteLine($"{product.productName}: {product.price:C}");
// Output:
// Laptop: $999.99

In het voorgaande voorbeeld leidt de compiler productName en price af als de eigenschapsnamen uit de variabelenamen die in de initialisatiefunctie worden gebruikt.

Anonieme typen declareren met var

Omdat de compiler de typenaam genereert en u er in de broncode geen toegang toe hebt, moet u var gebruiken om de lokale variabele te declareren. U kunt de typenaam niet expliciet opgeven:

// You must use var — you can't write a named type here.
var person = new { Name = "Alice", Age = 30 };

Anonieme typen gebruiken in LINQ-query's

Anonieme typen worden meestal weergegeven in de select component van een query-expressie, waarbij ze een subset van eigenschappen van elk bronelement projecteren:

var words = new[] { "apple", "blueberry", "cherry" };

var results = words.Select(w => new { Word = w, Length = w.Length });

foreach (var item in results)
{
    Console.WriteLine($"{item.Word} has {item.Length} letters.");
}
// Output:
// apple has 5 letters.
// blueberry has 9 letters.
// cherry has 6 letters.

Gelijkheid

Twee anonieme exemplaren met dezelfde eigenschapsnamen en typen in dezelfde volgorde delen hetzelfde door compiler gegenereerde type. De compiler overschrijft Equals en GetHashCode zodat gelijkheid eigenschapswaarden vergelijkt in plaats van referentie-identiteit:

var a = new { Name = "Alice", Age = 30 };
var b = new { Name = "Alice", Age = 30 };
var c = new { Name = "Bob", Age = 25 };

Console.WriteLine(a.Equals(b));  // True
Console.WriteLine(a.Equals(c));  // False

Geneste anonieme typen

Anonieme typen kunnen andere anonieme typen bevatten als eigenschapswaarden:

var order = new
{
    OrderId = 1,
    Customer = new { Name = "Alice", City = "Seattle" },
    Total = 150.00m
};
Console.WriteLine($"Order {order.OrderId} for {order.Customer.Name} in {order.Customer.City}");
// Output:
// Order 1 for Alice in Seattle

Kenmerken

Anonieme typen hebben de volgende kenmerken:

  • De compiler genereert deze als internal sealed class typen die zijn afgeleid van Object.
  • Alle eigenschappen zijn public en alleen lezen.
  • Anonieme typen ondersteunen with expressies voor niet-destructieve mutatie.
  • De compiler genereert waardegebaseerde Equals, GetHashCode, en ToString overschrijvingen.
  • Anonieme typen ondersteunen expressiestructuren, terwijl tuples dat niet doen.

Beperkingen

Anonieme typen hebben verschillende beperkingen:

  • U kunt deze niet gebruiken als retourtypen, methodeparameters of veldtypen omdat u het type niet kunt noemen.
  • Ze hebben de scope van de methode waarin u ze declareert.
  • U kunt geen methoden, gebeurtenissen of aangepaste operators toevoegen.
  • Eigenschappen zijn altijd alleen-lezen; anonieme typen bieden geen ondersteuning voor onveranderbare eigenschappen.

Wanneer moet u in plaats daarvan tuples gebruiken?

Voor de meeste nieuwe code kunt u overwegen tuples te gebruiken in plaats van anonieme typen. Als waardetypes bieden tuples betere prestaties. Ze bieden ook ondersteuning voor de deconstructie en flexibelere syntaxis. Anonieme typen blijven de beste keuze wanneer u ondersteuning voor expressiestructuur of verwijzingstype-semantiek nodig hebt. Zie Kiezen tussen anonieme typen en tuples voor een gedetailleerde vergelijking.

Zie ook

  • Last updated on