Jak przekazać anonimowe typy jako parametry?

Jak mogę przekazać anonimowe typy jako parametry do innych funkcji? Rozważmy ten przykład:

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

Zmienna querytutaj nie ma silnego typu. Jak zdefiniować LogEmployeesfunkcję, aby ją zaakceptować?

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

    }
}

Innymi słowy, czego powinienem używać zamiast ?znaków.

Myślę, że powinieneś stworzyć klasę dla tego anonimowego typu. Moim zdaniem byłoby to najbardziej sensowne. Ale jeśli naprawdę nie chcesz, możesz użyć dynamiki:

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

Zauważ, że nie jest to silnie wpisane, więc jeśli na przykład nazwa zmieni się na EmployeeName, nie będziesz wiedział, że wystąpił problem do czasu uruchomienia.

Możesz to zrobić w ten sposób:

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

    }
}

... ale nie będziesz miał wiele do zrobienia z każdym przedmiotem. Możesz wywołać ToString, ale nie będziesz mógł używać (powiedzmy) Namei Idbezpośrednio.

Niestety to, co próbujesz zrobić, jest niemożliwe. Pod maską zmienna zapytania jest wpisywana IEnumerablejako typu anonimowego. Nazwy typów anonimowych nie mogą być reprezentowane w kodzie użytkownika, dlatego nie ma możliwości uczynienia ich parametrem wejściowym dla funkcji.

Najlepszym rozwiązaniem jest utworzenie typu i użycie go jako wyniku zapytania, a następnie przekazanie go do funkcji. Na przykład,

struct Data {
  public string ColumnName; 
}

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

W tym przypadku jednak wybierasz tylko jedno pole, więc może być łatwiej po prostu wybrać pole bezpośrednio. Spowoduje to wpisanie zapytania jako IEnumerabletypu pola. W tym przypadku nazwa kolumny.

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

Nie można przekazać typu anonimowego do funkcji innej niż ogólna, chyba że typ parametru to object.

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

    foreach (var item in list)
    {

    }
}

Typy anonimowe są przeznaczone do krótkotrwałego użycia w ramach metody.

Z MSDN - typy anonimowe :

Nie można zadeklarować pola, właściwości, zdarzenia lub zwracanego typu metody jako typu anonimowego. Podobnie nie można zadeklarować formalnego parametru metody, właściwości, konstruktora lub indeksatora jako typu anonimowego. Aby przekazać typ anonimowy lub kolekcję zawierającą typy anonimowe jako argument do metody, można zadeklarować parametr jako obiekt typu . Jednak robienie tego jest sprzeczne z celem silnego pisania.

(podkreślenie moje)

Aktualizacja

Możesz użyć typów ogólnych, aby osiągnąć to, co chcesz:

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

    }
}

Zwykle robisz to za pomocą leków generycznych, na przykład:

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

Kompilator powinien następnie wywnioskować, Tkiedy wywołujesz MapEntToObj(query). Nie jestem do końca pewien, co chcesz zrobić w metodzie, więc nie mogę powiedzieć, czy jest to przydatne ... Problem polega na tym, że w środku MapEntToObjnadal nie możesz nazwać T- możesz albo:

• wywołać inne metody ogólne z T
• używaj refleksji Tdo robienia rzeczy

ale poza tym dość trudno jest manipulować typami anonimowymi - nie tylko dlatego, że są niezmienne ;-p

Kolejną sztuczką (przy wyodrębnianiu danych) jest również przekazanie selektora - czyli coś takiego:

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

Możesz użyć typów ogólnych z następującą sztuczką (rzutowanie na typ anonimowy):

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

W tym celu można również użyć terminu „dynamiczny”.

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

   }
}

Zamiast przekazywać anonimowy typ, przekaż Listę typu dynamicznego:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Podpis metody: DoSomething(List<dynamic> _dynamicResult)
3. Metoda połączenia: DoSomething(dynamicResult);
4. Gotowe.

Dzięki Petar Ivanov !

Jeśli wiesz, że twoje wyniki implementują pewien interfejs, możesz użyć interfejsu jako typu danych:

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

    }
}

Użyłbym IEnumerable<object>jako typu dla argumentu. Jednak nie jest to wielki zysk dla nieuniknionej wyraźnej obsady. Twoje zdrowie