Как передать анонимные типы в качестве параметров?

Как я могу передать анонимные типы в качестве параметров другим функциям? Рассмотрим этот пример:

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

Переменная queryздесь не имеет строгого типа. Как мне определить мою LogEmployeesфункцию, чтобы принять ее?

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

    }
}

Другими словами, что я должен использовать вместо ?знаков.

Я думаю, что вы должны сделать класс для этого анонимного типа. Это было бы наиболее разумно, по моему мнению. Но если вы действительно не хотите, вы можете использовать динамику:

public void LogEmployees (IEnumerable<dynamic> list)
{
    foreach (dynamic item in list)
    {
        string name = item.Name;
        int id = item.Id;
    }
}

Обратите внимание, что это не является строго типизированным, поэтому, если, например, имя изменяется на EmployeeName, вы не будете знать, что есть проблема до времени выполнения.

Вы можете сделать это так:

public void LogEmployees<T>(List<T> list) // Or IEnumerable<T> list
{
    foreach (T item in list)
    {

    }
}

... но вы не сможете сделать многое с каждым предметом. Вы можете вызвать ToString, но вы не сможете использовать (скажем) Nameи Idнапрямую.

К сожалению, то, что вы пытаетесь сделать, невозможно. Под капотом переменная запроса вводится IEnumerableкак анонимная. Имена анонимных типов не могут быть представлены в пользовательском коде, поэтому невозможно сделать их входным параметром функции.

Лучше всего создать тип и использовать его в качестве результата запроса, а затем передать его в функцию. Например,

struct Data {
  public string ColumnName; 
}

var query = (from name in some.Table
            select new Data { ColumnName = name });
MethodOp(query);
...
MethodOp(IEnumerable<Data> enumerable);

Однако в этом случае вы выбираете только одно поле, поэтому может быть проще просто выбрать поле напрямую. Это приведет к тому, что запрос будет напечатан как IEnumerableтип поля. В этом случае имя столбца.

var query = (from name in some.Table select name);  // IEnumerable<string>

Вы не можете передать анонимный тип не универсальной функции, если тип параметра не равен object.

public void LogEmployees (object obj)
{
    var list = obj as IEnumerable(); 
    if (list == null)
       return;

    foreach (var item in list)
    {

    }
}

Анонимные типы предназначены для краткосрочного использования в методе.

Из MSDN - анонимные типы :

Вы не можете объявить поле, свойство, событие или возвращаемый тип метода как имеющие анонимный тип. Аналогично, вы не можете объявить формальный параметр метода, свойства, конструктора или индексатора как имеющий анонимный тип. Чтобы передать анонимный тип или коллекцию, содержащую анонимные типы, в качестве аргумента метода, вы можете объявить параметр как объект типа . Тем не менее, это противоречит цели строгой типизации.

(акцент мой)

Обновить

Вы можете использовать дженерики для достижения желаемого:

public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (T item in list)
    {

    }
}

Обычно вы делаете это с помощью дженериков, например:

MapEntToObj<T>(IQueryable<T> query) {...}

Затем компилятор должен определить, Tкогда вы вызываете MapEntToObj(query). Не совсем уверен, что вы хотите сделать внутри метода, поэтому я не могу сказать, полезно ли это ... проблема в том, что внутри MapEntToObjвы все еще не можете назвать T- вы также можете:

• вызывать другие общие методы с T
• использовать отражение, Tчтобы делать вещи

но кроме этого, довольно трудно манипулировать анонимными типами - не в последнюю очередь потому, что они неизменны ;-p

Еще одна хитрость (при извлечении данных) - также передать селектор, то есть что-то вроде:

Foo<TSource, TValue>(IEnumerable<TSource> source,
        Func<TSource,string> name) {
    foreach(TSource item in source) Console.WriteLine(name(item));
}
...
Foo(query, x=>x.Title);

Вы можете использовать дженерики со следующим приемом (приведение к анонимному типу):

public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (T item in list)
    {
        var typedItem = Cast(item, new { Name = "", Id = 0 });
        // now you can use typedItem.Name, etc.
    }
}

static T Cast<T>(object obj, T type)
{
    return (T)obj;
}

«Динамический» также может быть использован для этой цели.

var anonymousType = new { Id = 1, Name = "A" };

var anonymousTypes = new[] { new { Id = 1, Name = "A" }, new { Id = 2, Name = "B" };

private void DisplayAnonymousType(dynamic anonymousType)
{
}

private void DisplayAnonymousTypes(IEnumerable<dynamic> anonymousTypes)
{
   foreach (var info in anonymousTypes)
   {

   }
}

Вместо передачи анонимного типа передайте список динамического типа:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Подпись метода: DoSomething(List<dynamic> _dynamicResult)
3. Метод вызова: DoSomething(dynamicResult);
4. сделано.

Спасибо Петру Иванову !

Если вы знаете, что ваши результаты реализуют определенный интерфейс, вы можете использовать интерфейс как тип данных:

public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (T item in list)
    {

    }
}

Я бы использовал IEnumerable<object>как тип для аргумента. Тем не менее, это не большой выигрыш для неизбежного явного приведения. ура