¿Cómo pasar tipos anónimos como parámetros?

¿Cómo puedo pasar tipos anónimos como parámetros a otras funciones? Considere este ejemplo:

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

La variable queryaquí no tiene un tipo fuerte. ¿Cómo debo definir mi LogEmployeesfunción para aceptarla?

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

    }
}

En otras palabras, ¿qué debo usar en lugar de ?marcas?

Creo que deberías hacer una clase para este tipo anónimo. Eso sería lo más sensato que hacer en mi opinión. Pero si realmente no quieres, puedes usar la dinámica:

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

Tenga en cuenta que esto no está fuertemente tipeado, por lo que si, por ejemplo, Nombre cambia a EmployeeName, no sabrá que hay un problema hasta el tiempo de ejecución.

Puedes hacerlo así:

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

    }
}

... pero no podrás hacer mucho con cada artículo. Puede llamar a ToString, pero no podrá usar (por ejemplo) Namey Iddirectamente.

Desafortunadamente, lo que estás tratando de hacer es imposible. Bajo el capó, la variable de consulta se escribe para ser IEnumerablede tipo anónimo. Los nombres de tipos anónimos no se pueden representar en el código de usuario, por lo tanto, no hay forma de convertirlos en un parámetro de entrada para una función.

Su mejor opción es crear un tipo y usarlo como el retorno de la consulta y luego pasarlo a la función. Por ejemplo,

struct Data {
  public string ColumnName; 
}

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

Sin embargo, en este caso, solo está seleccionando un solo campo, por lo que puede ser más fácil seleccionar el campo directamente. Esto hará que la consulta se escriba como IEnumerabledel tipo de campo. En este caso, nombre de columna.

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

No puede pasar un tipo anónimo a una función no genérica, a menos que el tipo de parámetro sea object.

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

    foreach (var item in list)
    {

    }
}

Los tipos anónimos están destinados al uso a corto plazo dentro de un método.

De MSDN - Tipos anónimos :

No puede declarar que un campo, una propiedad, un evento o el tipo de retorno de un método tenga un tipo anónimo. Del mismo modo, no puede declarar que un parámetro formal de un método, propiedad, constructor o indexador tenga un tipo anónimo. Para pasar un tipo anónimo, o una colección que contiene tipos anónimos, como argumento para un método, puede declarar el parámetro como objeto de tipo . Sin embargo, hacer esto anula el propósito de escribir con fuerza.

(énfasis mío)

Actualizar

Puedes usar genéricos para lograr lo que quieres:

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

    }
}

Normalmente, haces esto con genéricos, por ejemplo:

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

El compilador debe inferir Tcuándo llama MapEntToObj(query). No estoy muy seguro de lo que quiere hacer dentro del método, por lo que no puedo decir si esto es útil ... el problema es que dentro de MapEntToObjusted todavía no puede nombrar el T- usted puede:

• llamar a otros métodos genéricos con T
• usar la reflexión Tpara hacer cosas

pero aparte de eso, es bastante difícil manipular tipos anónimos, sobre todo porque son inmutables ;-p

Otro truco (al extraer datos) es también pasar un selector, es decir, 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);

Puedes usar genéricos con el siguiente truco (conversión a 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" también se puede utilizar para este propósito.

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

   }
}

En lugar de pasar un tipo anónimo, pase una Lista de un tipo dinámico:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Firma del método: DoSomething(List<dynamic> _dynamicResult)
3. Método de llamada: DoSomething(dynamicResult);
4. hecho.

Gracias a Petar Ivanov !

Si sabe que sus resultados implementan una determinada interfaz, puede usar la interfaz como tipo de datos:

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

    }
}

Lo usaría IEnumerable<object>como tipo para el argumento. Sin embargo, no es una gran ganancia para el elenco explícito inevitable. Salud