How to pass anonymous types as parameters in C#

To pass anonymous types as parameters in this example.

For example:

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?

You can use the following approaches.

For example, Use Generics

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

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.