What are anonymous types in C#? Explain what the compiler generates, how equality and immutability work, why == behaves differently from Equals, when two anonymous types share a type, their use in LINQ projections and EF Core, and their limits compared with tuples and records.

1. Generated type shape

[CompilerGenerated, DebuggerDisplay("\\{ OrderId = {OrderId}, Total = {Total} }")]
internal sealed class <>f__AnonymousType0<<OrderId>j__TPar, <Total>j__TPar>
{
    private readonly <OrderId>j__TPar <OrderId>i__Field;
    private readonly <Total>j__TPar <Total>i__Field;
    public <OrderId>j__TPar OrderId => <OrderId>i__Field;
    public <Total>j__TPar Total => <Total>i__Field;
    public override bool Equals(object? value) { ... EqualityComparer<T>.Default for each field ... }
    public override int GetHashCode() { ... combines field hashes with constants ... }
    public override string ToString() { ... }
}

Being generic over property types means one generated class definition is reused for all anonymous types with the same property names in the same order (instantiated with different types).

2. Expression trees

In IQueryable projections, new { o.Id, o.Total } becomes a NewExpression with Members information. EF Core maps each member to a column and constructs the anonymous object in the shaper. That's why anonymous types work in EF Core projections while tuple literals ((o.Id, o.Total)) can't be used in expression trees (CS8143).

3. GroupBy and composite keys

Anonymous types as keys rely on generated Equals/GetHashCode. In EF Core, GroupBy(o => new { o.Region, o.Year }) translates to GROUP BY [Region], [Year]. In LINQ to Objects, the keys are hashed via the generated GetHashCode.

4. with on anonymous types (C# 10)

anon with { Total = 0 } creates a new instance of the same anonymous type. Because properties are read-only, with is the only way to "change" one.

5. Serialisation

System.Text.Json serialises anonymous types by reading their public properties — names preserved. Deserialisation into anonymous types isn't directly supported (no parameterless constructor/setters), though you can deserialise into an anonymous-type "template" with some libraries (Newtonsoft's DeserializeAnonymousType).

6. Performance

Each anonymous object is a heap allocation. In hot LINQ pipelines over in-memory data (e.g. Select(x => new { x.A, x.B }) on millions of items), consider value tuples or structs instead to avoid allocations — but note tuples lose names at run time.

Try it yourself

1. Create two anonymous objects with the same values and compare with == and Equals.
2. Create anonymous types with the same properties in different order and try assigning one to the other.
3. Project to an anonymous type in EF Core and inspect ToQueryString().
4. Try returning an anonymous type from a method; then switch to a record.

namespace Advanced.AnonymousTypes;

public sealed record Sale(string Region, int Month, decimal Amount);
public sealed record SalesKey(string Region, int Month);

public static class Program
{
    public static void Main()
    {
        var a = new { Id = 1, Name = "Ava" };
        var b = new { Id = 1, Name = "Ava" };
        Console.WriteLine(a.Equals(b));                 // True: value equality
        Console.WriteLine(a == b);                      // False: reference equality, no operator ==
        Console.WriteLine(a.GetType() == b.GetType());  // True: same shape, same type

        var reordered = new { Name = "Ava", Id = 1 };
        Console.WriteLine(a.GetType() == reordered.GetType()); // False: order matters

        var renamed = a with { Name = "Noah" };          // C# 10
        Console.WriteLine(renamed);                     // { Id = 1, Name = Noah }

        List<Sale> sales = [new("AU", 1, 100m), new("AU", 1, 50m), new("NZ", 2, 70m)];

        // Composite key: works because of value equality
        var totals = sales
            .GroupBy(s => new { s.Region, s.Month })
            .Select(g => new { g.Key.Region, g.Key.Month, Total = g.Sum(s => s.Amount) })
            .ToList();
        foreach (var t in totals) Console.WriteLine($"{t.Region}/{t.Month}: {t.Total}");

        // Crossing a method boundary: switch to a named type
        IReadOnlyDictionary<SalesKey, decimal> publicResult = totals.ToDictionary(t => new SalesKey(t.Region, t.Month), t => t.Total);
        Console.WriteLine(publicResult[new SalesKey("AU", 1)]);
    }
}