Come utilizzare la riflessione per semplificare costruttori e confronti?

Question

Odio avere un sacco di metodi "sinistra/destra". Ogni volta che una proprietà viene aggiunta o rimossa, devo correggere ogni metodo. E il codice stesso sembra ... sbagliato.

public Foo(Foo other) 
{ 
    this.Bar = other.Bar; 
    this.Baz = other.Baz; 
    this.Lur = other.Lur; 
    this.Qux = other.Qux; 
    this.Xyzzy= other.Xyzzy; 
} 

In realtà questo è solo un loop srotolato che consente di scorrere le proprietà, copiandoli tra gli oggetti. Quindi, perché non essere onesti su questo fatto? Riflessione in soccorso!

public Foo(IFoo other) 
{ 
    foreach (var property in typeof(IFoo).GetProperties()) 
    { 
     property.SetValue(this, property.GetValue(other, null), null); 
    } 
} 

posso solo cercare di forzare un paradigma che ho imparato da Lua in C#, ma questo particolare esempio non sembra troppo puzzolente a me. Da qui, ho iniziato a fare alcune cose più complesse che erano sensibili all'ordine dei campi. Ad esempio, piuttosto che avere una pila di praticamente identiche if dichiarazioni per comporre una stringa dai campi, ho appena scorrere su di loro nell'ordine desiderato:

public override string ToString() 
{ 
    var toJoin = new List<string>(); 
    foreach (var property in tostringFields) 
    { 
     object value = property.GetValue(this, null); 
     if (value != null) 
      toJoin.Add(value.ToString()); 
    } 
    return string.Join(" ", toJoin.ToArray()); 
} 
private static readonly PropertyInfo[] tostringFields = 
{ 
    typeof(IFoo).GetProperty("Bar"), 
    typeof(IFoo).GetProperty("Baz"), 
    typeof(IFoo).GetProperty("Lur"), 
    typeof(IFoo).GetProperty("Qux"), 
    typeof(IFoo).GetProperty("Xyzzy"), 
}; 

Così ora ho l'iterabilità che volevo, ma ho ancora ho stack di codice che rispecchiano ogni proprietà a cui sono interessato (lo sto facendo anche per CompareTo, usando un diverso insieme di proprietà in un ordine diverso). Peggio ancora, è la perdita della tipizzazione forte. Questo sta davvero iniziando a sentire l'odore.

E che dire degli attributi su ogni proprietà per definire l'ordine? Ho iniziato su questa strada e in effetti ha funzionato bene, ma ha semplicemente reso tutto gonfio. Funziona alla grande semanticamente, ma sono sempre cauto nell'usare funzioni avanzate solo perché sono "pulite". Sta usando il riflesso in questo modo eccessivo? C'è qualche altra soluzione al problema del codice sinistro/destro che mi manca?

Answer 1

L'uso della riflessione in sé e per sé non è male, ma si verificherà un calo di prestazioni, soprattutto se lo si fa in modo ricorsivo.

Non sono un fan dei costruttori di copia hardcoded sia perché gli sviluppatori dimenticano di aggiornarli quando aggiungono nuove proprietà a una classe.

Esistono altri modi per realizzare ciò che si desidera, tra cui Marc Gravells Hyper Property Descriptor o se si desidera conoscere alcuni IL e OPCodes è possibile utilizzare System.Reflection.Emit o anche Cecil from Mono.

Ecco un esempio di utilizzo di Hyper proprietà descrittore che si può eventualmente su misura per le vostre esigenze:

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using Hyper.ComponentModel; 
namespace Test { 
    class Person { 
     public int Id { get; set; } 
     public string Name { get; set; } 
    } 
    class Program { 
     static void Main() { 
      HyperTypeDescriptionProvider.Add(typeof(Person)); 
      var properties = new Dictionary<string, object> { { "Id", 10 }, { "Name", "Fred Flintstone" } }; 
      Person person = new Person(); 
      DynamicUpdate(person, properties); 
      Console.WriteLine("Id: {0}; Name: {1}", person.Id, person.Name); 
      Console.ReadKey(); 
     } 
     public static void DynamicUpdate<T>(T entity, Dictionary<string, object> { 
      foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(typeof(T))) 
       if (properties.ContainsKey(propertyDescriptor.Name)) 
        propertyDescriptor.SetValue(entity, properties[propertyDescriptor.Name]); 
     } 
    } 
} 

Se si decide di continuare ad usare la riflessione, è possibile ridurre le prestazioni colpito da caching le chiamate a GetProperties () in questo modo:

public Foo(IFoo other) { 
    foreach (var property in MyCacheProvider.GetProperties<IFoo>()) 
     property.SetValue(this, property.GetValue(other, null), null); 
} 

Answer 2

IMHO, la riflessione è una caratteristica molto potente di C#, ma che è molto suscettibile di provocare un codice gonfio, e che aggiunge molto alla curva di apprendimento del codice e riduce manutenibilità. Avrai maggiori probabilità di commettere errori (una volta che il refactoring di base potrebbe portare a errori) e più paura di cambiare il nome di qualsiasi proprietà (se trovi un nome migliore) o cose del genere.

Personalmente ho un codice con un problema simile, e ho avuto la stessa idea di aggiungere attributi per mantenere l'ordine e così via. Ma il mio team (incluso me) ha pensato che fosse meglio perdere un po 'di tempo cambiando il design per non aver bisogno Questo. Forse questo problema è causato da un cattivo design (beh, era nel mio caso, ma non posso dire lo stesso del tuo).

Answer 3

So che c'è già una risposta a questo, ma volevo sottolineare che esiste una libreria che combina alcune delle strategie di mitigazione per l'impatto sulle prestazioni che alcune persone hanno discusso.

La libreria è denominata AutoMapper e esegue il mapping da un oggetto a un altro e lo fa creando dinamicamente un assembly IL al volo. Questo assicura che diverso da un primo colpo volta, si ottiene prestazioni superiori e il tuo codice sarebbe molto più semplice:

public Foo(Foo other) 
{ 
    Mapper.Map(other, this); 
} 

Questo tende a funzionare grande e ha il vantaggio di non essere inventato qui, che io sono un fan di.

Ho eseguito alcuni test delle prestazioni e dopo il primo hit di 20 ms (ancora piuttosto veloce) era circa il più vicino possibile a 0. Molto impressionante.

Spero che questo aiuti qualcuno.

Answer 4

Il problema di base è che si sta tentando di utilizzare un linguaggio tipizzato in modo statico come un tipo tipizzato dinamicamente.

Non c'è davvero bisogno di niente di speciale. Se si desidera poter iterare le proprietà, è possibile utilizzare una mappa <> come archivio di supporto per tutte le proprietà della classe.

Per coincidenza, questo è esattamente il modo in cui il wizard di progetto VS implora le impostazioni dell'applicazione. (Vedi System.Configuration.ApplicationSettingsBase) E 'anche molto 'lua-like'

public bool ConfirmSync { 
     get { 
      return ((bool)(this["ConfirmSync"])); 
     } 
     set { 
      this["ConfirmSync"] = value; 
     } 
    }