Dela via

Anonyma typer (C#-programmeringsguide)

Anonyma typer är ett bekvämt sätt att kapsla in en uppsättning skrivskyddade egenskaper i ett enda objekt utan att definiera en namngiven typ först. Kompilatorn genererar ett typnamn vid kompileringstiden som du inte kan komma åt i källkoden. Kompilatorn härleder typen av varje egenskap.

Skapa anonyma typer med hjälp av operatorn new tillsammans med en objektinitierare. I följande exempel visas en anonym typ som initieras med två egenskaper och NameAge:

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

Härledda egenskapsnamn

Du kan uttryckligen ange egenskapsnamn med hjälp av syntaxen Name = value . När du initierar en anonym typ med ett variabel- eller medlemsåtkomstuttryck härleder kompilatorn egenskapsnamnet från det uttrycket:

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

I det föregående exemplet härleder kompilatorn productName och price som egenskapsnamn från de variabelnamn som används i initieraren.

Deklarera anonyma typer med var

Eftersom kompilatorn genererar typnamnet och du inte kan komma åt det i källkoden måste du använda var för att deklarera den lokala variabeln. Du kan inte uttryckligen ange typnamnet:

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

Använda anonyma typer i LINQ-frågor

Anonyma typer visas oftast i -satsen i select ett frågeuttryck, där de projicerar en delmängd av egenskaper från varje källelement:

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.

Jämlikhet

Två anonyma typinstanser som har samma egenskapsnamn och typer i samma ordning delar samma kompilatorgenererade typ. Kompilatorn åsidosätter Equals och GetHashCode så att likhet jämför egenskapsvärden i stället för referensidentitet:

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

Kapslade anonyma typer

Anonyma typer kan innehålla andra anonyma typer som egenskapsvärden:

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

Egenskaper

Anonyma typer har följande egenskaper:

  • Kompilatorn genererar dem som internal sealed class typer som härleds från Object.
  • Alla egenskaper är public och skrivskyddade.
  • Anonyma typer stöder with uttryck för icke-förstörande mutation.
  • Kompilatorn genererar värdebaserade Equals, GetHashCodeoch ToString åsidosättningar.
  • Anonyma typer stöder uttrycksträd, medan tupplar inte gör det.

Begränsningar

Anonyma typer har flera begränsningar:

  • Du kan inte använda dem som metodreturtyper, metodparametrar eller fälttyper eftersom du inte kan namnge typen.
  • De är begränsade till metoden där du deklarerar dem.
  • Du kan inte lägga till metoder, händelser eller anpassade operatorer.
  • Egenskaper är alltid skrivskyddade. Anonyma typer stöder inte ändringsbara egenskaper.

När du ska använda tupplar i stället

Överväg att använda tupplar i stället för anonyma typer för de flesta nya kodtyper. Tupplar ger bättre prestanda som värdetyper. De ger också dekonstruktionsstöd och mer flexibel syntax. Anonyma typer är fortfarande det bättre valet när du behöver stöd för uttrycksträd eller semantik av referenstyp. En detaljerad jämförelse finns i Välja mellan anonyma typer och tupppeltyper.

Se även

  • Last updated on