Come passare i tipi anonimi come parametri?

Come posso passare tipi anonimi come parametri ad altre funzioni? Considera questo esempio:

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

La variabile queryqui non ha un tipo forte. Come devo definire la mia LogEmployeesfunzione per accettarla?

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

    }
}

In altre parole, cosa dovrei usare al posto dei ?segni.

Penso che dovresti fare un corso per questo tipo anonimo. Secondo me sarebbe la cosa più sensata da fare. Ma se davvero non vuoi, potresti usare la dinamica:

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

Si noti che questo non è fortemente tipizzato, quindi se, ad esempio, Nome cambia in EmployeeName, non si saprà che c'è un problema fino al runtime.

Puoi farlo in questo modo:

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

    }
}

... ma non dovrai fare molto con ogni oggetto. Potresti chiamare ToString, ma non sarai in grado di usare (diciamo) Namee Iddirettamente.

Sfortunatamente, quello che stai cercando di fare è impossibile. Sotto il cofano, la variabile di query viene digitata per essere IEnumerabledi tipo anonimo. I nomi di tipo anonimo non possono essere rappresentati nel codice utente, pertanto non è possibile renderli un parametro di input per una funzione.

La soluzione migliore è creare un tipo e utilizzarlo come ritorno dalla query, quindi passarlo alla funzione. Per esempio,

struct Data {
  public string ColumnName; 
}

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

In questo caso, tuttavia, stai solo selezionando un singolo campo, quindi potrebbe essere più semplice selezionare direttamente il campo. Ciò causerà la digitazione della query come IEnumerabledi tipo di campo. In questo caso, il nome della colonna.

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

Non è possibile passare un tipo anonimo a una funzione non generica, a meno che non sia il tipo di parametro object.

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

    foreach (var item in list)
    {

    }
}

I tipi anonimi sono destinati all'uso a breve termine all'interno di un metodo.

Da MSDN - Tipi anonimi :

Non è possibile dichiarare un campo, una proprietà, un evento o il tipo restituito di un metodo con un tipo anonimo. Allo stesso modo, non è possibile dichiarare un parametro formale di un metodo, proprietà, costruttore o indicizzatore con un tipo anonimo. Per passare un tipo anonimo o una raccolta che contiene tipi anonimi, come argomento a un metodo, è possibile dichiarare il parametro come oggetto type . Tuttavia, fare questo sconfigge lo scopo della digitazione forte.

(enfatizzare il mio)

Aggiornare

Puoi usare generici per ottenere ciò che desideri:

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

    }
}

Normalmente, lo fai con generici, ad esempio:

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

Il compilatore dovrebbe quindi dedurre Tquando si chiama MapEntToObj(query). Non sono sicuro di cosa tu voglia fare all'interno del metodo, quindi non posso dire se questo sia utile ... il problema è che dentro di MapEntToObjte non puoi ancora nominare il T- puoi anche:

• chiama altri metodi generici con T
• usa la riflessione Tper fare le cose

ma a parte questo, è abbastanza difficile manipolare i tipi anonimi - non ultimo perché sono immutabili ;-p

Un altro trucco (durante l' estrazione di dati) è anche passare un selettore, ovvero qualcosa del tipo:

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

Puoi usare i generici con il seguente trucco (passando al tipo anonimo):

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

"dinamico" può essere utilizzato anche per questo scopo.

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

   }
}

Invece di passare un tipo anonimo, passa un Elenco di un tipo dinamico:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Firma del metodo: DoSomething(List<dynamic> _dynamicResult)
3. Metodo di chiamata: DoSomething(dynamicResult);
4. fatto.

Grazie a Petar Ivanov !

Se sai che i tuoi risultati implementano una determinata interfaccia, puoi utilizzare l'interfaccia come tipo di dati:

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

    }
}

Vorrei usare IEnumerable<object>come tipo per l'argomento. Comunque non è un grande guadagno per l'inevitabile cast esplicito. Saluti