Comment passer des types anonymes en tant que paramètres ?

Question

Comment puis-je passer des types anonymes comme paramètres à d'autres fonctions ? Prenons l'exemple suivant :

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

La variable query ici n'a pas de type fort. Comment dois-je définir mon LogEmployees fonction pour l'accepter ?

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

    }
}

En d'autres termes, que dois-je utiliser à la place de ? des marques.

Answer 1

Je pense que vous devriez créer une classe pour ce type d'anonyme. Ce serait la chose la plus sensée à faire à mon avis. Mais si vous ne voulez vraiment pas le faire, vous pouvez utiliser la dynamique :

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

Notez que c'est pas fortement typée, de sorte que si, par exemple, Name devient EmployeeName, vous ne saurez pas qu'il y a un problème avant l'exécution.

Answer 2

Vous pouvez le faire comme ça :

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

    }
}

... mais vous ne pourrez pas faire grand-chose avec chaque élément. Vous pouvez appeler ToString, mais vous ne pourrez pas utiliser (disons) Name et Id directement.

Answer 3

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

Le mieux est de créer un type et de l'utiliser comme retour de la requête, puis de le passer dans 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, cependant, vous ne sélectionnez qu'un seul champ. Il peut donc être plus facile de sélectionner directement le champ. La requête sera alors saisie sous la forme d'un champ de type IEnumerable du type de champ. Dans ce cas, il s'agit du nom de la colonne.

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

Answer 4

Vous ne pouvez pas passer un type anonyme à une fonction non générique, sauf si le type du paramètre est object .

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

    foreach (var item in list)
    {

    }
}

Les types anonymes sont destinés à être utilisés à court terme dans une méthode.

De MSDN - Types d'anonymes :

Vous ne pouvez pas déclarer un champ, une propriété, un événement ou le type de retour d'une méthode comme ayant un type anonyme. De même, vous ne pouvez pas déclarer un paramètre formel d'une méthode, d'une propriété, d'un constructeur ou d'un indexeur comme ayant un type anonyme. Pour passer un type anonyme, ou une collection qui contient des types anonymes, comme argument d'une méthode, vous pouvez déclarer le paramètre comme type objet . Cependant, cela va à l'encontre de l'objectif du typage fort.

(c'est moi qui souligne)

---

Mise à jour

Vous pouvez utiliser des génériques pour obtenir ce que vous voulez :

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

    }
}

Answer 5

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

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

Le compilateur doit alors déduire le T quand vous appelez MapEntToObj(query) . Je ne sais pas exactement ce que vous voulez faire à l'intérieur de la méthode, donc je ne peux pas dire si cela est utile... le problème est qu'à l'intérieur de la méthode MapEntToObj vous ne pouvez toujours pas nommer le T - vous pouvez soit :

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

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

Une autre astuce (lorsque en extrayant data) est de passer également un sélecteur - c'est-à-dire 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);