Leistung dynamische vs Reflexion

Question

Ich habe folgende Möglichkeiten Werte in einer Liste abrufen:

Reflexion mit:

foreach (var item in items) { 
    var property=item.Fields[fieldName].GetType().GetProperty("Id"); 
    var value=property.GetValue(item.Fields[fieldName]); 
    if (value==searchValue) { 
     filtered.Add(item); 
    } 
} 

mit dynamisch:

foreach (var item in items) { 
    dynamic itemProperty=item.Fields[fieldName]; 
    if (itemProperty.Id==searchValue) { 
     filtered.Add(item); 
    } 
} 

Beiden Schleifen das gleiche tun. Sie filtern IEnumerable (oder List) nach Field [fieldName], die verschiedenen Typen aber alle eine Int-Eigenschaft namens "Id" enthalten können.

Ich frage mich, was würde man eine bessere Leistung haben. Zusätzlich: Würde eine Änderung der LinQ-Abfrage die Performance erhöhen?

Answer 1

Die einfachste Weg, dies zu tun IMO ist eine Schnittstelle zu definieren, die eine int Id {get;} Eigenschaft hat und Ihre Typen implementieren. Dann Code an die Schnittstelle. Wenn Ihr vorhandener Code generisch könnten Sie sogar in der Lage sein, eine where T : IYourInterface Einschränkung hinzuzufügen, aber Sie können auf IYourInterface oder so werfen (unter der Annahme T tatsächlich die Schnittstelle nicht implementiert).

Wenn Schnittstellen sind keine Option:

Reflexion und dynamic beide Gemeinkosten haben; dynamic hat eine bessere Optimierung (Wiederverwendung einer zwischengespeicherten Strategie).

Wenn Ihr items Liste ist stark an eine bestimmte getippt T (wo T hier unbekannt ist), dann können Sie möglicherweise dieses Konzept weiter optimieren LINQ Ausdrücke Delegierten zu kompilieren:

static class IdFetcher 
{ 
    public static int Fetch<T>(T item) => IdFetcher<T>.Fetch(item); 
} 
static class IdFetcher<T> 
{ 
    public static int Fetch(T item) => fetch(item); 
    static readonly Func<T, int> fetch; 
    static IdFetcher() 
    { 
     var p = Expression.Parameter(typeof(T), "item"); 
     fetch = Expression.Lambda<Func<T, int>>(
      Expression.PropertyOrField(p, "Id"), p).Compile(); 
    } 
} 

Dann benutzen Sie einfach IdFetcher<T>.Fetch(obj) oder IdFetcher.Fetch(obj) (die erste ist direkter; die zweite ist nützlich für anonyme Typen, wo Sie die T nicht angeben können)

Andere als das: wenn Sie möchte wissen, was schneller ist: Zeit sie (für eine große Anzahl von Iterationen).