c# - mvc - mapper initialize

¿Permitir la asignación de tipos dinámicos utilizando AutoMapper o similar?

Question

Empecé a usar https://github.com/robconery/massive para un proyecto, me pregunto si hay alguna herramienta de mapeo que permita el soporte de mapeo de tipo dinámico a estático

He usado AutoMapper anteriormente, ¿AutoMapper soporta esto?

Soy consciente de la función DynamicMap de AutoMapper, sin embargo, creo que esta función es para ejecutar mapas sin crear el Mapa primero. En mi ejemplo a continuación no funciona.

dynamic curUser = users.GetSingleUser(UserID);   
var retUser = Mapper.DynamicMap<UserModel>(curUser);
users.GetSingleUser(UserID); // returns a dynamic object

Answer 1

Pruebe Slapper.AutoMapper https://github.com/randyburden/Slapper.AutoMapper

Slapper.AutoMapper mapea datos dinámicos a tipos estáticos

Funciona tanto para dynamic como para Dictionary<A, B> que es impresionante.

Aquí hay un ejemplo (tomado de la URL anterior) que muestra qué tan fácil funciona con el Diccionario:

public class Person
{
    public int Id;
    public string FirstName;
    public string LastName;
}

[Test]
public void CanMapMatchingFieldNamesWithEase()
{
    // Arrange
    var dictionary = new Dictionary<string, object>
                            {
                                { "Id", 1 },
                                { "FirstName", "Clark" },
                                { "LastName", "Kent" }
                            };

    // Act
    var person = Slapper.AutoMapper.Map<Person>( dictionary );

    // Assert
    Assert.NotNull( person );
    Assert.That( person.Id == 1 );
    Assert.That( person.FirstName == "Clark" );
    Assert.That( person.LastName == "Kent" );
}

Answer 2

Suponiendo que el marco que usa devuelva ExpandoObject , puede lograr algún tipo de asignación dinámica utilizando AutoMapper:

Mapper.CreateMap<ExpandoObject, UserModel>()
    .ForAllMembers((options) => options.ResolveUsing((resolution) =>
        {
            var dictionary =  (IDictionary<string, object>) resolution.Context.SourceValue;
            return dictionary[resolution.Context.MemberName];
        }));
...
dynamic CurUser = _users.GetSingleUser(UserID);   
var retUser = Mapper.Map<UserModel>(CurUser);

Puedes crear cualquier tipo de mapeo complejo usando métodos de ConstructUsing uso.

Answer 3

Un solo objeto:

Mapper.Map<Product>(dynamicProduct);

Lista:

Mapper.Map<List<Product>>(dynamicListOfProducts);

Ejemplo (línea 71): https://github.com/AutoMapper/AutoMapper/blob/master/src/UnitTests/DynamicMapping.cs

Answer 4

AutoMapper 4.2.0 ahora admite el mapeo dinámico / expando / diccionario

Con esta función puede asignar objetos expanda a tipos estáticos:

dynamic CurUser = _users.GetSingleUser(UserID);   
var config = new MapperConfiguration(cfg => { });
var mapper = config.CreateMapper();

var retUser = mapper.Map<UserModel>(CurUser);

Las versiones anteriores de AutoMapper no lo admiten (Massive usa ExpandoObject que no proporciona las propiedades que tiene), y tiene razón Mapper.DynamicMap es para mapear sin crear una configuración de mapeo.

En realidad, no es difícil escribirte un mapeador si solo quieres un mapeo simple:

public static class DynamicToStatic
{
    public static T ToStatic<T>(object expando)
    {
        var entity = Activator.CreateInstance<T>();

        //ExpandoObject implements dictionary
        var properties = expando as IDictionary<string, object>; 

        if (properties == null)
            return entity;

        foreach (var entry in properties)
        {
            var propertyInfo = entity.GetType().GetProperty(entry.Key);
            if(propertyInfo!=null)
                propertyInfo.SetValue(entity, entry.Value, null);
        }
        return entity;
    }
}

dynamic CurUser = _users.GetSingleUser(UserID);   
var retUser = DynamicToStatic.ToStatic<UserModel>(CurUser);