Comment passer des types anonymes comme paramètres?

Vous pouvez le faire comme ceci:

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

    }
}

... mais vous n'obtiendrez pas beaucoup à faire avec chaque élément. Vous pouvez appeler ToString, mais vous ne pourrez pas utiliser (dire) Name et Id directement.

Malheureusement, ce que vous essayez de faire est impossible. Sous le capot, la variable de requête est tapée pour être un IEnumerable d'un type anonyme. Les noms de type anonymes ne peuvent pas être représentés dans le code d'utilisateur, il n'y a donc aucun moyen de les transformer en paramètre d'entrée d'une fonction.

Votre meilleur pari est de créer un type et de l'utiliser comme retour de la requête, puis le passer à la fonction. Par exemple,

struct Data {
  public string ColumnName; 
}

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

dans ce cas bien que vous ne sélectionniez qu'un seul champ, il peut donc être plus facile de le sélectionner directement. Ceci fera que la requête sera tapée comme un IEnumerable du type de champ. Dans ce cas, le nom de colonne.

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

vous ne pouvez pas passer un type anonyme à une fonction non générique, à moins que le type de paramètre ne soit object .

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

    foreach (var item in list)
    {

    }
}

anonymes sont destinés à une utilisation à court terme dans le cadre d'une méthode.

à Partir de MSDN - Anonyme "Types de 151990920" :

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

    }
}

normalement, vous faites cela avec des génériques, par exemple:

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

le compilateur devrait alors inférer le T quand vous appelez MapEntToObj(query) . Pas tout à fait sûr de ce que vous voulez faire à l'intérieur de la méthode, donc je ne peux pas dire si c'est utile... le problème est que dans MapEntToObj vous ne pouvez toujours pas nommer le T - vous pouvez soit:

• appeler d'autres méthodes génériques avec T
• utilisation réflexion sur T faire des choses

mais à part cela, il est assez difficile de manipuler les types anonymes-notamment parce qu'ils sont immuables; - p

un autre truc (quand extraire données) est de passer aussi un sélecteur - i.e. quelque chose comme:

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

vous pouvez utiliser des génériques avec le truc suivant (casting au type anonyme):

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

"dynamique" peut également être utilisé à cette fin.

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

   }
}

au lieu de passer un type anonyme, passer une liste d'un type dynamique:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. méthode signature: DoSomething(List<dynamic> _dynamicResult)
3. méthode D'appel: DoSomething(dynamicResult);
4. fait.

merci à Petar Ivanov !

si vous savez que vos résultats implémentent une certaine interface, vous pouvez utiliser l'interface comme type de données:

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

    }
}

j'utiliserais IEnumerable<object> comme type pour l'argument. Cependant pas un grand gain pour la distribution explicite inévitable. Cheers