Comment passer des types anonymes comme paramètres?

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

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

La variable queryici n'a pas de type fort. Comment définir ma LogEmployeesfonction pour l'accepter?

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

    }
}

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

Je pense que vous devriez créer une classe pour ce type anonyme. Ce serait la chose la plus sensée à faire à mon avis. Mais si vous ne voulez vraiment pas, 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 ce n'est pas fortement typé, donc si, par exemple, Name change en EmployeeName, vous ne saurez pas qu'il y a un problème avant l'exécution.

Vous pouvez le faire comme ceci:

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 (par exemple) Nameet Iddirectement.

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

Votre meilleur pari est de créer un type et de l'utiliser comme retour de la requête, puis de le transmettre à 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 le champ directement. Cela entraînera la saisie de la requête en tant que type IEnumerablede champ. Dans ce cas, nom de la 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, sauf si le type de 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 à une utilisation à court terme dans une méthode.

Depuis MSDN - Types 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, en tant qu'argument à une méthode, vous pouvez déclarer le paramètre comme objet de type . Cependant, cela va à l'encontre de l'objectif d'un typage fort.

(c'est moi qui souligne)

Mettre à jour

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

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 doit alors déduire le Tmoment où vous appelez MapEntToObj(query). Je ne sais pas trop 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 MapEntToObjvous ne pouvez toujours pas nommer le T- vous pouvez non plus:

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

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

Une autre astuce (lors de l' extraction de données) 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);

Vous pouvez utiliser des génériques avec l'astuce suivante (conversion en 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, passez une List d'un type dynamique:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Signature de la méthode: DoSomething(List<dynamic> _dynamicResult)
3. Méthode d'appel: DoSomething(dynamicResult);
4. terminé.

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, ce n'est pas un grand gain pour l'incontournable casting explicite. À votre santé