resolveusing - Automapper: cómo asignar a los parámetros del constructor en lugar de establecer las propiedades

automapper reversemap

Question

En los casos en que mis establecedores de destino son privados, me gustaría asignar al objeto utilizando el constructor del objeto de destino. ¿Cómo harías esto usando Automapper?

Answer 1

Debe usar el método Map que le permite establecer el destino. Por ejemplo :

Mapper.CreateMap<ObjectFrom, ObjectTo>()

var from = new ObjectFrom { Name = "Jon", Age = 25 };

var to = Mapper.Map(from, new ObjectTo(param1));

Answer 2

En el momento de escribir esta respuesta, AutoMapper lo hará automáticamente (con una simple CreateMap<>() ) si las propiedades coinciden con los parámetros del constructor. Por supuesto, si las cosas no coinciden, entonces usar .ConstructUsing(...) es el camino a seguir.

public class PersonViewModel
{
    public int Id { get; set; }

    public string Name { get; set; }
}

public class Person
{
    public Person (int id, string name)
    {
        Id = id;
        Name = name;
    }

    public int Id { get; }

    public string Name { get; }
}

public class PersonProfile : Profile
{
    public PersonProfile()
    {
        CreateMap<PersonProfile, Person>();
    }
}

Nota: Esto supone que está utilizando Profiles para configurar sus asignaciones de Automapper.

Cuando se utiliza como a continuación, esto produce el objeto correcto:

var model = new PersonModel
{
    Id = 1
    Name = "John Smith"
}

// will correctly call the (id, name) constructor of Person
_mapper.Map<Person>(model);

Puede leer más sobre la construcción de Automapper en la https://github.com/AutoMapper/AutoMapper/wiki/Construction oficial https://github.com/AutoMapper/AutoMapper/wiki/Construction

Answer 3

La mejor práctica es utilizar enfoques documentados de AutoMapper https://github.com/AutoMapper/AutoMapper/wiki/Construction

public class SourceDto
{
        public SourceDto(int valueParamSomeOtherName)
        {
            Value = valueParamSomeOtherName;
        }

        public int Value { get; }
}

Mapper.Initialize(cfg => cfg.CreateMap<Source, SourceDto>().ForCtorParam("valueParamSomeOtherName", opt => opt.MapFrom(src => src.Value)));

Answer 4

Use ConstructUsing

esto le permitirá especificar qué constructor usar durante la asignación. pero luego todas las otras propiedades se mapearán automáticamente de acuerdo con las convenciones.

También tenga en cuenta que esto es diferente de ConvertUsing en que el uso de conversiones no continuará ConvertUsing a través de las convenciones, sino que le dará un control total de la asignación.

Mapper.CreateMap<ObjectFrom, ObjectTo>()
    .ConstructUsing(x => new ObjectTo(arg0, arg1, etc));

...

using AutoMapper;
using NUnit.Framework;

namespace UnitTests
{
    [TestFixture]
    public class Tester
    {
        [Test]
        public void Test_ConstructUsing()
        {
            Mapper.CreateMap<ObjectFrom, ObjectTo>()
                .ConstructUsing(x => new ObjectTo(x.Name));

            var from = new ObjectFrom { Name = "Jon", Age = 25 };

            ObjectTo to = Mapper.Map<ObjectFrom, ObjectTo>(from);

            Assert.That(to.Name, Is.EqualTo(from.Name));
            Assert.That(to.Age, Is.EqualTo(from.Age));
        }
    }

    public class ObjectFrom
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    public class ObjectTo
    {
        private readonly string _name;

        public ObjectTo(string name)
        {
            _name = name;
        }

        public string Name
        {
            get { return _name; }
        }

        public int Age { get; set; }
    }
}