AutoMapper: asignación utilizando los mismos tipos de objetos de origen y destino

Question

Uso Automapper para tomar dos objetos del mismo tipo y asignar los nuevos valores que hayan cambiado. Intenté usar el siguiente código, pero sigue arrojando un error y ni siquiera estoy seguro de si esto se puede lograr con Automapper.

Por ejemplo:

 Mapper.CreateMap<UserDetails, UserDetails>(); 
     UserDetails userDetails = Mapper.Map<UserDetails, UserDetails>(userDetailsCurrent, userDetailsNew); 

Básicamente, necesito copiar a través de cualquiera de los valores nuevos que vienen en el nuevo objeto "userDetailsNew" a la "userDetailsCurrent" objeto existente - a pesar de que son del mismo tipo . De esta forma puedo "actualizar" el objeto existente con los nuevos valores. La razón por la que hago esto es porque no estoy seguro de qué datos de usuario se enviarán; necesito asignarlos cuando lleguen.

Normalmente he usado Automapper para mapear diferentes objetos con propiedades similares, pero pensé que podría usar el poder de Automapper para lograr lo mismo de esta manera. Incluso podría haber una solución mejor, ¡cualquier ayuda sería apreciada!

Answer 1

Esto parece funcionar para mí. Mi tipo personalizado:

class MyType 
{ 
    public int MyInt { get; set; } 
    public string MyString { get; set; } 
} 

mi código de correspondencia:

Mapper.CreateMap<MyType, MyType>(); 
var source = new MyType() {MyInt = 1, MyString = "Hello world"}; 
var dest = Mapper.Map<MyType, MyType>(source); 

Lo que es interesante acerca de su tipo personalizado más allá de simples propiedades?

Answer 2

Esto se puede hacer usando tuplas y creando un convertidor de tipo personalizado derivado de la clase Abstract TypeConverter de Automapper.

Supongamos que tenía una clase de origen y destino de:

public class Person 
{ 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 

    public override string ToString() 
    { 
     return string.Format("Firstname: {0}, Lastname: {1}", FirstName, LastName); 
    } 
} 

Posteriormente, se podría construir el tipo de convertidor personalizado como

public class CustomerPersonConverter : TypeConverter<Tuple<Person, Person>, Person> 
{ 
    protected override Person ConvertCore(Tuple<Person, Person> source) 
    { 
     var orginalValues = source.Item1; 
     var updatedValues = source.Item2; 

     var result = new Person 
      { 
       FirstName = string.IsNullOrEmpty(updatedValues.FirstName) ? orginalValues.FirstName : updatedValues.FirstName, 
       LastName = string.IsNullOrEmpty(updatedValues.LastName) ? orginalValues.LastName : updatedValues.LastName 
      }; 

     return result; 
    } 
} 

que podría ser utilizado como

var orginal = new Person() {FirstName = "Clifford", LastName = "Mayson"}; 
     var updated = new Person() {FirstName = "Cliff"}; 

     Mapper.CreateMap<Tuple<Person, Person>, Person>().ConvertUsing<CustomerPersonConverter>(); 

     var result = Mapper.Map<Person>(new Tuple<Person, Person>(orginal, updated)); 

     Console.WriteLine(result); 

Qué produciría el resultado de mantener el valor del apellido original ya que faltaba en la actualización pero se actualiza ting el valor del nombre, por ej.

Firstname: Cliff, Lastname: Mayson