Permetti il ​​mapping di tipi dinamici usando AutoMapper o simili?

Question

Ho iniziato a utilizzare https://github.com/robconery/massive per un progetto, mi chiedo se esiste uno strumento di mappatura che consente il supporto per il mapping di tipo statico dinamico?

Ho usato AutoMapper in precedenza, AutoMapper supporta questo?

Sono a conoscenza della funzione DynamicMap di AutoMapper, tuttavia ritengo che questa funzione sia per l'esecuzione di mappe senza prima creare la mappa. Nel mio esempio qui sotto non funziona.

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

Answer 1

AutoMapper 4.2.0 ora supporta Dynamic/expando/dictionary mapping

Con questa funzione è possibile associare agli oggetti expando ai tipi statici:

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

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

Le vecchie versioni di automapper non supportano questa (utilizza Massive internamente ExpandoObject che non fornisce le proprietà che ha), e hai ragione: Mapper.DynamicMap è per il mapping senza creare la configurazione del mapping.

In realtà non è difficile scrivere voi stessi un mapper se si desidera solo semplice mappatura:

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); 

Answer 2

Prova Slapper.AutoMapperhttps://github.com/randyburden/Slapper.AutoMapper

Slapper.AutoMapper associa i dati dinamici ai tipi statici

Funziona sia per dynamic e Dictionary<A, B> che è fantastico.

Ecco un esempio (tratto dal URL sopra) che mostra quanto facilmente funziona con il dizionario:

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 3

Supponendo quadro si utilizza rendimenti ExpandoObject si possono ottenere una sorta di mappatura dinamica utilizzando 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); 

È possibile creare qualsiasi tipo di mappatura complesso utilizzando metodi ConstructUsing ..

Answer 4

singolo oggetto:

Mapper.Map<Product>(dynamicProduct); 

Elenco:

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

Esempio (linea 71): https://github.com/AutoMapper/AutoMapper/blob/master/src/UnitTests/DynamicMapping.cs