2010-03-09 13 views
10

Tengo un montón de clases de contrato de datos generados-XSD.exe que para todos los elementos opcionales tienen un par de C Propiedades # comoAutoMapper y es * propiedades especificadas

int Amount {get; set;} 
bool isAmountSpecified {get; set;} 

En el otro lado de arena mapeo tengo un int anulable como

int? Amount {get; set;} 

Idealmente me gustaría que AutoMapper sea capaz de reconocer tales patrones y saber cómo asignar cosas en ambas direcciones sin tener que especificar una asignación para cada propiedad individual. es posible?

+0

Creo que esto podría ayudar http://valueinjecter.codeplex.com/documentation, solo tiene que especificar un algoritmo de asignación para int a int? una vez y usarlo para cualquier objeto que necesite, no tiene que crear mapas para cada par de tipos – Omu

Respuesta

1

Honestamente, no tengo idea de si AutoMapper hará eso (ya que no uso mucho AutoMapper), pero sé que protobuf-net admite ambos patrones, por lo que podría usar Serializer.ChangeType<,>(obj) para alternar entre ellos.

La versión actual es, sin embargo, bastante dependiente de tener atributos (como [XmlElement(Order = n)]) en los miembros - No sé si eso causa un problema? La versión en progreso admite tipos simples (sin atributos), pero aún no está completa (pero pronto).

Ejemplo:

[XmlType] 
public class Foo 
{ 
    [XmlElement(Order=1)] 
    public int? Value { get; set; } 
} 
[XmlType] 
public class Bar 
{ 
    [XmlElement(Order = 1)] 
    public int Value { get; set; } 
    [XmlIgnore] 
    public bool ValueSpecified { get; set; } 
} 
static class Program 
{ 
    static void Main() 
    { 
     Foo foo = new Foo { Value = 123 }; 
     Bar bar = Serializer.ChangeType<Foo, Bar>(foo); 
     Console.WriteLine("{0}, {1}", bar.Value, bar.ValueSpecified); 

     foo = new Foo { Value = null }; 
     bar = Serializer.ChangeType<Foo, Bar>(foo); 
     Console.WriteLine("{0}, {1}", bar.Value, bar.ValueSpecified); 

     bar = new Bar { Value = 123, ValueSpecified = true }; 
     foo = Serializer.ChangeType<Bar, Foo>(bar); 
     Console.WriteLine(foo.Value); 

     bar = new Bar { Value = 123, ValueSpecified = false }; 
     foo = Serializer.ChangeType<Bar, Foo>(bar); 
     Console.WriteLine(foo.Value); 
    } 
} 
+0

@Marc, gracias por la información - No sabía acerca de protobuf-net, voy a echar un vistazo. –

2

bien, ayer he tenido una breve discusión con Jimmy Bogard, autor de AutoMapper, y básicamente lo que estoy buscando en este momento no es posible. El soporte para tales convenciones será implementado en algún momento en el futuro (si lo entendí correctamente :)).

Cuestiones relacionadas