¿Cómo usar la reflexión para simplificar constructores y comparaciones?

Question

Odio tener un montón de métodos "izquierda/derecha". Cada vez que se agrega o elimina una propiedad, tengo que arreglar cada método. Y el código en sí mismo se ve ... mal.

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

Realmente esto es sólo un bucle desenrollado que recorre en iteración las propiedades, ellos copiando entre objetos. Entonces, ¿por qué no ser honesto sobre ese hecho? Reflexión al rescate!

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

que puede simplemente estar tratando de forzar un paradigma que aprendí de Lua en C#, pero este ejemplo en particular, no parece demasiado mal olor a mí. A partir de aquí, empecé a hacer cosas más complejas que eran sensibles al orden de los campos. Por ejemplo, en lugar de tener una pila de if declaraciones casi idénticas a componer una cadena a partir de los campos, sólo iterar sobre ellos en el orden deseado:

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"), 
}; 

Así que ahora tengo el iterabilidad que quería, pero todavía tienen montones de código duplicando cada propiedad que me interesa (también estoy haciendo esto para CompareTo, usando un conjunto diferente de propiedades en un orden diferente). Peor que eso es la pérdida de tipeo fuerte. Esto realmente está empezando a oler.

¿Y qué hay del uso de atributos en cada propiedad para definir el orden? Empecé por este camino y de hecho funcionó bien, pero simplemente hizo que todo pareciera hinchado. Funciona muy bien semánticamente, pero siempre tengo cuidado con el uso de funciones avanzadas simplemente porque son "ordenadas". ¿Usar la reflexión de esta manera es excesiva? ¿Hay alguna otra solución al problema del código izquierdo/derecho que me falta?

Answer 1

Usar el reflejo en sí mismo no es malo, pero tendrá un impacto en el rendimiento, especialmente si lo hace recursivamente.

No soy seguidor de los constructores de copias codificadas, ya sea porque los desarrolladores olvidan actualizarlos cuando agregan nuevas propiedades a una clase.

Existen otras maneras de lograr lo que desea, incluyendo Marc Gravells Hyper Property Descriptor o si desea aprender algunos IL y OPCodes, puede usar System.Reflection.Emit o incluso Cecil from Mono.

He aquí un ejemplo del uso de Hyper propiedad descriptor que posiblemente puede adaptar a sus necesidades:

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

Si decide continuar utilizando la reflexión, se puede reducir el rendimiento alcanzado por el almacenamiento en caché sus llamadas a GetProperties (), así:

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

Answer 2

en mi humilde opinión, la reflexión es una característica muy potente de C#, pero que es muy probable que resulte en un código hinchado, y que añade mucho a la curva de aprendizaje del código y reduce el mantenimiento. Es más probable que cometa errores (una vez que la refactorización básica puede generar errores) y más miedo a cambiar el nombre de cualquier propiedad (si encuentra un nombre mejor) o cosas por el estilo.

Personalmente tengo un código con un problema similar, y tenía la misma idea de agregar atributos para mantener el orden, etc. Pero mi equipo (incluyéndome a mí) pensó que era mejor perder algo de tiempo cambiando el diseño para no necesitarlo esta. Tal vez este problema esté causado por un diseño incorrecto (bueno, fue en mi caso, pero no puedo decir lo mismo sobre el tuyo).

Answer 3

sé que ya hay una respuesta a esto, pero quería señalar que hay una biblioteca que combina algunas de las estrategias de mitigación del impacto en el rendimiento que algunas personas han discutido.

La biblioteca se llama AutoMapper y se correlaciona de un objeto a otro y lo hace al crear dinámicamente un ensamblado IL sobre la marcha. Esto asegura que no sea un golpe primera vez, se obtiene un rendimiento superior y su código sería mucho más simple:

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

Esto tiende a funcionar muy bien y tiene la ventaja añadida de no ser inventado aquí, que soy una fan de.

Hice algunas pruebas de rendimiento y después del primer golpe de 20 ms (siendo bastante rápido) era lo más cercano a 0 como usted puede conseguir. Muy impresionante.

Espero que esto ayude a alguien.

Answer 4

El problema básico es que están tratando de utilizar un lenguaje de tipos estáticos como un tipo dinámico uno.

No hay realmente una necesidad de algo sofisticado. Si desea poder iterar las propiedades, puede usar un Map <> como la tienda de respaldo para todas las propiedades en su clase.

Coincidentemente así es exactamente como los parámetros de la aplicación implmements asistente de proyectos VS para usted. (Ver System.Configuration.ApplicationSettingsBase) también es muy 'lua-como'

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