Wie übergebe ich anonyme Typen als Parameter?

Wie kann ich anonyme Typen als Parameter an andere Funktionen übergeben? Betrachten Sie dieses Beispiel:

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

Die Variable query hier hat keinen starken Typ. Wie soll ich meine LogEmployeesFunktion definieren , um sie zu akzeptieren?

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

    }
}

Mit anderen Worten, was soll ich anstelle von verwenden ? Markierungen verwenden.

Ich denke, Sie sollten eine Klasse für diesen anonymen Typ erstellen. Das wäre meiner Meinung nach das Vernünftigste. Aber wenn Sie wirklich nicht wollen, können Sie Dynamik verwenden:

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

Beachten Sie, dass dies nicht stark typisiert ist. Wenn sich beispielsweise Name in EmployeeName ändert, wissen Sie erst zur Laufzeit, dass ein Problem vorliegt.

Sie können es so machen:

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

    }
}

... aber Sie werden nicht viel mit jedem Gegenstand anfangen können. Sie könnten ToString nennen, aber Sie werden nutzen können (sagen wir) nicht Nameund Iddirekt.

Leider ist das, was Sie versuchen, unmöglich. Unter der Haube wird die Abfragevariable IEnumerableals anonymer Typ eingegeben . Anonyme Typnamen können nicht im Benutzercode dargestellt werden, daher gibt es keine Möglichkeit, sie zu einem Eingabeparameter für eine Funktion zu machen.

Am besten erstellen Sie einen Typ und verwenden diesen als Rückgabe aus der Abfrage und übergeben ihn dann an die Funktion. Beispielsweise,

struct Data {
  public string ColumnName; 
}

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

In diesem Fall wählen Sie jedoch nur ein einzelnes Feld aus, sodass es möglicherweise einfacher ist, das Feld direkt auszuwählen. Dadurch wird die Abfrage als Feldtyp eingegeben IEnumerable. In diesem Fall Spaltenname.

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

Sie können einen anonymen Typ nicht an eine nicht generische Funktion übergeben, es sei denn, der Parametertyp ist object.

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

    foreach (var item in list)
    {

    }
}

Anonyme Typen sind für die kurzfristige Verwendung innerhalb einer Methode vorgesehen.

Von MSDN - Anonyme Typen :

Sie können ein Feld, eine Eigenschaft, ein Ereignis oder den Rückgabetyp einer Methode nicht als anonym deklarieren. Ebenso können Sie einen formalen Parameter einer Methode, Eigenschaft, eines Konstruktors oder eines Indexers nicht als anonym deklarieren. Um einen anonymen Typ oder eine Sammlung, die anonyme Typen enthält, als Argument an eine Methode zu übergeben, können Sie den Parameter als Typobjekt deklarieren . Dies macht jedoch den Zweck einer starken Eingabe zunichte.

(Hervorhebung von mir)

Aktualisieren

Sie können Generika verwenden, um das zu erreichen, was Sie wollen:

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

    }
}

Normalerweise tun Sie dies mit Generika, zum Beispiel:

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

Der Compiler sollte dann Tbeim Aufrufen auf das schließen MapEntToObj(query). Ich bin mir nicht ganz sicher, was Sie innerhalb der Methode tun möchten, daher kann ich nicht sagen, ob dies nützlich ist. Das Problem ist, dass MapEntToObjSie die Methode immer noch nicht benennen können T- Sie können auch:

• Rufen Sie andere generische Methoden mit auf T
• Verwenden Sie Reflexion über T, um Dinge zu tun

Ansonsten ist es ziemlich schwierig, anonyme Typen zu manipulieren - nicht zuletzt, weil sie unveränderlich sind ;-p

Ein weiterer Trick (beim Extrahieren von Daten) besteht darin, auch einen Selektor zu übergeben - dh so etwas wie:

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

Sie können Generika mit dem folgenden Trick verwenden (Casting in einen anonymen Typ):

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

Zu diesem Zweck kann auch "dynamisch" verwendet werden.

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

   }
}

Anstatt einen anonymen Typ zu übergeben, übergeben Sie eine Liste eines dynamischen Typs:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Methodensignatur: DoSomething(List<dynamic> _dynamicResult)
3. Aufrufmethode: DoSomething(dynamicResult);
4. getan.

Vielen Dank an Petar Ivanov !

Wenn Sie wissen, dass Ihre Ergebnisse eine bestimmte Schnittstelle implementieren, können Sie die Schnittstelle als Datentyp verwenden:

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

    }
}

Ich würde IEnumerable<object>als Typ für das Argument verwenden. Allerdings kein großer Gewinn für die unvermeidliche explizite Besetzung. Prost