Como passar tipos anônimos como parâmetros?

Como posso passar tipos anônimos como parâmetros para outras funções? Considere este exemplo:

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

A variável queryaqui não tem um tipo forte. Como devo definir minha LogEmployeesfunção para aceitá-la?

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

    }
}

Em outras palavras, o que devo usar em vez de ?marcas.

Eu acho que você deveria fazer uma aula para esse tipo anônimo. Isso seria a coisa mais sensata a se fazer na minha opinião. Mas se você realmente não quiser, poderá usar a dinâmica:

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

Observe que isso não é fortemente digitado; portanto, se, por exemplo, Name mudar para EmployeeName, você não saberá que há um problema até o tempo de execução.

Você pode fazer assim:

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

    }
}

... mas você não poderá fazer muito com cada item. Você pode ligar para o ToString, mas não poderá usar (por exemplo) Namee Iddiretamente.

Infelizmente, o que você está tentando fazer é impossível. Sob o capô, a variável de consulta é digitado para ser um IEnumerablede um tipo anônimo. Nomes de tipos anônimos não podem ser representados no código do usuário, portanto, não há como torná-los um parâmetro de entrada para uma função.

Sua melhor aposta é criar um tipo e usá-lo como o retorno da consulta e depois passá-lo para a função. Por exemplo,

struct Data {
  public string ColumnName; 
}

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

Nesse caso, porém, você está selecionando apenas um único campo; portanto, pode ser mais fácil selecionar o campo diretamente. Isso fará com que a consulta seja digitada como IEnumerabledo tipo de campo. Nesse caso, nome da coluna.

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

Você não pode passar um tipo anônimo para uma função não genérica, a menos que o tipo de parâmetro seja object.

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

    foreach (var item in list)
    {

    }
}

Tipos anônimos destinam-se ao uso de curto prazo dentro de um método.

Do MSDN - Tipos anônimos :

Você não pode declarar um campo, uma propriedade, um evento ou o tipo de retorno de um método como tendo um tipo anônimo. Da mesma forma, você não pode declarar um parâmetro formal de um método, propriedade, construtor ou indexador como tendo um tipo anônimo. Para passar um tipo anônimo ou uma coleção que contém tipos anônimos, como argumento para um método, você pode declarar o parâmetro como objeto de tipo . No entanto, fazer isso anula o objetivo da digitação forte.

(ênfase minha)

Atualizar

Você pode usar genéricos para alcançar o que deseja:

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

    }
}

Normalmente, você faz isso com genéricos, por exemplo:

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

O compilador deve inferir o Tquando você chama MapEntToObj(query). Não tenho certeza do que você deseja fazer dentro do método, então não sei dizer se isso é útil ... o problema é que, MapEntToObjainda dentro, você não pode nomear o nome T- você pode:

• chame outros métodos genéricos com T
• use a reflexão Tpara fazer as coisas

mas, além disso, é muito difícil manipular tipos anônimos - principalmente porque são imutáveis ​​;-p

Outro truque (ao extrair dados) é também passar um seletor - ou seja, algo como:

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

Você pode usar genéricos com o seguinte truque (conversão para o tipo anônimo):

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;
}

"dinâmico" também pode ser usado para esse fim.

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)
   {

   }
}

Em vez de passar um tipo anônimo, passe uma lista de um tipo dinâmico:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Assinatura do método: DoSomething(List<dynamic> _dynamicResult)
3. Método de chamada: DoSomething(dynamicResult);
4. feito.

Obrigado a Petar Ivanov !

Se você sabe que seus resultados implementam uma certa interface, você pode usá-la como tipo de dados:

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

    }
}

Eu usaria IEnumerable<object>como tipo para o argumento. No entanto, não é um grande ganho para o elenco explícito inevitável. Felicidades