Practical applications of anonymous types

  • 7 minutes

Imagine you're preparing a quick summary of items in a warehouse. Instead of creating detailed records for each item, you jot down only the key details you need, like the name and price, on a temporary list. This approach helps you stay organized without unnecessary complexity. Anonymous types in C# work similarly they let you group related data into a temporary object without defining a full class, making your code simpler and more efficient.

Understand the concept of anonymous types

Anonymous types allow you to create objects with read-only properties without defining a class. The compiler generates a name for the type, which isn't accessible at the source code level. The compiler determines the type of each property.

  • Anonymous types are created using the new operator and object initializers.
  • They're commonly used in Language-Integrated Query (LINQ) queries to return subsets of properties from objects.

For example:

var v = new { Amount = 108, Message = "Hello" };
Console.WriteLine($"{v.Amount} - {v.Message}");

Note

Anonymous types can't include methods, events, or null values as property initializers.

Create anonymous types using object initializers

You can create anonymous types using the new operator combined with object initializers. Anonymous types simplify the creation of temporary objects.

The following code demonstrates how to create an anonymous type:

var product = new { Name = "Laptop", Price = 1200 };
Console.WriteLine($"Product: {product.Name}, Price: {product.Price}");
  • If member names aren't explicitly provided, the compiler uses the names of the properties being initialized.
  • Anonymous types are often declared using implicitly typed variables (var).

Tip

Use anonymous types for temporary data structures where defining a full class would be unnecessary.

Use anonymous types in LINQ queries

Anonymous types are commonly used in LINQ queries to project results into objects with selected properties. Anonymous types allow you to work with only the data you need.

The following LINQ query demonstrates how to project an anonymous type:

var products = new[] {
    new { Name = "Laptop", Price = 1200 },
    new { Name = "Tablet", Price = 600 }
};

var filteredProducts = from p in products
                       where p.Price > 1000
                       select new { p.Name, p.Price };

foreach (var product in filteredProducts)
{
    Console.WriteLine($"Name: {product.Name}, Price: {product.Price}");
}
  • The select clause creates instances of anonymous types.
  • The query returns an IEnumerable of the anonymous type.

Note

Anonymous types are internal, so they can't be passed across assembly boundaries.

Compare anonymous types and tuple types

Anonymous types and tuple types both allow grouping of related data but differ in usability and performance.

Feature Anonymous Types Tuple Types
Type Reference type (class) Value type (struct)
Custom member names Supported Supported
Deconstruction Not supported Supported
Expression tree support Supported Not supported
  • Anonymous types are read-only and support expression trees.
  • Tuples are mutable and support deconstruction.

Tip

Use anonymous types for LINQ queries and expression trees, and tuples for scenarios requiring mutability or deconstruction.

Implement anonymous types

Anonymous types are ideal for creating temporary data structures within the scope of a method. They simplify code and reduce the need for defining more classes.

In the following example, an anonymous type is used to group data temporarily:

var customer = new { Name = "Mario Rogers", Age = 30 };
Console.WriteLine($"Customer: {customer.Name}, Age: {customer.Age}");
  • Anonymous types are useful for scenarios where the type isn't needed beyond the method scope.
  • They can't be used as method parameters or return types.

Caution

Avoid relying on the compiler-generated name of an anonymous type, as it occasionally varies between compilations.

Anonymous types in C# provide an efficient way to group related data into temporary objects without defining a full class. They're useful in LINQ queries and scenarios where a lightweight, read-only structure is sufficient. While anonymous types are powerful, they're limited to internal use and can't be passed across assembly boundaries.

By learning how to create and use anonymous types, you can simplify your code and focus on the data that matters most. Use them for temporary data structures, quick projections in LINQ queries, and scenarios where defining a full class would be unnecessary.