c# - memberlist - automapper reverse map

Automapper dice que Mapper.Map está obsoleto, ¿mapeos globales?

Question

Había definido en mi proyecto una configuración de Automapper global que me permitiría usar Mapper.Map<targetType>(sourceObject); en mi codigo (Ver mi configuración a continuación.)

Actualicé el paquete NuGet y veo el mensaje de que Mapper.Map está obsoleto / depreciado. Volví a Automapper en GitHub y veo ejemplos como este:

[Test]
public void Example()
{
    var config = new MapperConfiguration(cfg =>
    {
        cfg.CreateMap<Source1, SubDest1>().FixRootDest();
        cfg.CreateMap<Source2, SubDest2>().FixRootDest();
    });

    config.AssertConfigurationIsValid();

    var mapper = config.CreateMapper();

    var subDest1 = mapper.Map<Source1, SubDest1>(new Source1 {SomeValue = "Value1"});
    var subDest2 = mapper.Map<Source2, SubDest2>(new Source2 {SomeOtherValue = "Value2"});

    subDest1.SomeValue.ShouldEqual("Value1");
    subDest2.SomeOtherValue.ShouldEqual("Value2");
}

¿Voy a tener que crear una configuración en CADA método que use un mapeo?

Mi configuración global actual:

namespace PublicationSystem.App_Start
{
    public class AutoMapperConfig
    {
        public static void CreateMaps()
        {
            CreateProjectMaps();
        }

        private static void CreateProjectMaps()
        {
            Mapper.CreateMap<Project, ProjectCreate>();
            Mapper.CreateMap<Project, ProjectSelectable>();
            //...
        }
    }
}

ACTUALIZACIÓN: Gracias a un entrenamiento de Scott Chamberlain, he creado una clase como esta:

    public class MkpMapperProfile : AutoMapper.Profile
    {
        protected override void Configure() 
        {
            this.CreateMap<Project, ProjectCreate>();

            this.CreateMap<Project, ProjectSelectable>();

            this.CreateMap<Project, ProjectDetails>();

            // Many Many other maps
        }
    }

Estoy pensando que debería tener la ''MapperConfiguration'' en mi clase BaseController. Comencé a hacer algo como esto:

public partial class BaseController : Controller
{

    private MapperConfiguration mapConfig;

    public BaseController()
    {
        db = new MkpContext();
        SetMapperConfig();
    }

    private void SetMapperConfig()
    {
        mapConfig = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile<MkpMapperProfile>();
            });
    }

    public BaseController(MapperConfiguration config)
    {
        db = new MkpContext();
        this.mapConfig = config;
    }
}

¿Estoy en el camino correcto?

Answer 1

Así es como lo he manejado.

Cree mapas en un perfil, teniendo cuidado de usar el método CreateMap del perfil en lugar del método estático de Mapper del mismo nombre:

internal class MappingProfile : Profile
{
    protected override void Configure()
    {
        CreateMap<Project, ProjectCreate>();
    }
}

Luego, donde sea que estén conectadas las dependencias (por ejemplo: Global.asax o Inicio), cree una Configuración de Mapper y luego úsela para crear un IMapper.

var mapperConfiguration = new MapperConfiguration(cfg =>
    {
        cfg.AddProfile(new MappingProfile());
    });

Luego, usa la configuración para generar un IMapper:

var mapper = mapperConfiguration.CreateMapper();

Luego, registre ese asignador con el generador de dependencias (aquí estoy usando Autofac)

builder.RegisterInstance(mapper).As<IMapper>();

Ahora, donde sea que necesite mapear cosas, declare una dependencia en IMapper:

internal class ProjectService : IProjectService {
    private readonly IMapper _mapper;
    public ProjectService(IMapper mapper) {
         _mapper = mapper;
    }
    public ProjectCreate Get(string key) {
        var project = GetProjectSomehow(key);
        return _mapper.Map<Project, ProjectCreate>(project);
    }
}

Answer 2

Esto es nuevo en AutoMapper 4.2. Hay una publicación de blog de Jimmy Bogard sobre esto: Eliminación de la API estática de AutoMapper . Afirma que

La interfaz de IMapper es mucho más ligera, y el tipo subyacente ahora solo se ocupa de ejecutar mapas, eliminando muchos de los problemas de subprocesamiento ...

La nueva sintaxis: (pegada desde la publicación del blog)

var config = new MapperConfiguration(cfg => {
  cfg.CreateMap<User, UserDto>();
});

Si solo quieres la "vieja manera" de hacer esto. La última versión 4.2.1 ha traído alguna tradición. Solo usa

CreateMap<Project, ProjectCreate>();

en lugar de

Mapper.CreateMap<Project, ProjectCreate>();

El código antiguo funcionará bien.

Answer 3

Estoy usando la versión 5.2.0, soporte para crear mapas en constructores en lugar de anular la configuración.

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Project, ProjectDto>();
    }
}

En Global.asax.cs llamamos como:

Mapper.Initialize(c=>c.AddProfile<MappingProfile>());

Espero que esto ayude.

Answer 4

Puede encontrar el AutoMapper 4.2 configurado en el proyecto de mi Plantilla ASP.NET MVC aquí: https://github.com/NikolayIT/ASP.NET-MVC-Template

1. Cree estas clases: https://github.com/NikolayIT/ASP.NET-MVC-Template/tree/master/ASP.NET%20MVC%205/Web/MvcTemplate.Web.Infrastructure/Mapping

2. IMapFrom<> modelos de vista con IMapFrom<> : https://github.com/NikolayIT/ASP.NET-MVC-Template/blob/master/ASP.NET%20Core/Web/AspNetCoreTemplate.Web/ViewModels/Settings/SettingViewModel.cs

3. Úselo como .To<SomeViewModel>() . Ejemplo: https://github.com/NikolayIT/ASP.NET-MVC-Template/blob/master/ASP.NET%20MVC%205/Web/MvcTemplate.Web/Controllers/HomeController.cs#L27

Answer 5

Mapper.Initialize(cfg => {
    cfg.CreateMap<Source, Dest>();
});