How to pass anonymous types as parameters in C#

C# Anonymous Type

Anonymous types allow you to group read-only properties into a single object without explicitly defining a type. The compiler generates the type name, which isn't available in the code, and infers the type of each property.

You create them using the new operator with an object initializer.

For example, Creating an Anonymous Type in C#

var person = new { Name = "Alice", Age = 25 };

In this example, the compiler implicitly creates a class with Name and Age properties. You cannot directly reference this type because it doesn't have a name.

C# Anonymous type as parameter

For example, pass anonymous type as parameter c#

var query = from e in employees select new { e.Name, e.Id };
LogEmployees(query);

public void LogEmployees (? list)
{
    foreach (? item in list)
    {
    }
}

The variable query here doesn't have a strong type. How can I define the LogEmployees function to accept it?

For example, Use Generics

You can make the LogEmployees method generic to handle the anonymous type.

// c# anonymous type as parameter
public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (var item in list)
    {
        Console.WriteLine(item);
    }
}

This way, the compiler infers the type of the anonymous object from the query variable.

LogEmployees(query);

If you prefer not to use generics, you can use dynamic to bypass type checking, dynamic allows you to handle anonymous types at runtime

For example, Use dynamic

public void LogEmployees(dynamic list)
{
    foreach (var item in list)
    {
        Console.WriteLine($"{item.Id} - {item.Name});
    }
}

Using dynamic is not strongly typed, so changes like renaming a property (e.g., from Name to EmployeeName) won't be caught at compile time. This can lead to runtime errors, making the code less reliable and harder to maintain. Strong typing, such as defining a class or using generics, is a safer alternative.

If you know the data structure at compile time, you can use tuples instead of anonymous types:

For example, Use Tuples

public void LogEmployees(IEnumerable<(string Name, int Id)> list)
{
    foreach (var item in list)
    {
        Console.WriteLine($"{item.Id} - {item.Name});
    }
}

In most cases, generics is the preferred solution for working with anonymous types.

C# Anonymous Object as Parameter

In C#, you can pass an anonymous object as a parameter, but the key thing to remember is that anonymous objects are of a dynamic type and don't have a fixed type like a class or struct.

Therefore, the method parameter should accept an object, dynamic, or an interface that is compatible with the structure of the anonymous object.

For example, Using object type

using System;

public class Program
{
    public static void Main()
    {
        var anonymousObject = new { Name = "John", Age = 30 };
        Print(anonymousObject);
    }

    public static void Print(object obj)
    {
        dynamic dynamicObj = obj; // Casting to dynamic for ease of use
        Console.WriteLine($"Name: {dynamicObj.Name}, Age: {dynamicObj.Age}");
    }
}

In this example:

• The PrintAnonymousObject method accepts an object type.
• Inside the method, the object is cast to dynamic to access its properties dynamically.

For example, Using dynamic type

using System;

public class Program
{
    public static void Main()
    {
        var anonymousObject = new { Name = "John", Age = 30 };
        Print(anonymousObject);
    }

    public static void Print(dynamic obj)
    {
        Console.WriteLine($"Name: {obj.Name}, Age: {obj.Age}");
    }
}

In this case, the parameter is directly defined as dynamic, allowing direct access to the properties without the need for explicit casting.

Noted:

• Anonymous objects are defined within a method or limited scope, so they can't be passed directly to methods expecting specific classes or interfaces unless explicitly cast.
• When using dynamic, you lose compile-time checking, and you will get runtime errors if properties are accessed incorrectly.