Automapper risolve il tipo di destinazione in base al valore di un'enumerazione nel tipo di fonte

Question

Sto cercando un modo per Automapper di selezionare il tipo di destinazione di una chiamata da mappare, in base a un valore Enum impostato nel tipo di origine.

ad es. Date le seguenti classi:

public class Organisation 
{ 
    public string Name {get;set;} 
    public List<Metric> Metrics {get;set;} 
} 

public class Metric 
{ 
    public int NumericValue {get;set;} 
    public string TextValue {get;set;} 
    public MetricType MetricType {get;set;} 
} 

public enum MetricType 
{ 
    NumericMetric, 
    TextMetric 
} 

Se ho il seguente oggetto:

var Org = new Organisation { 
    Name = "MyOrganisation", 
    Metrics = new List<Metric>{ 
     new Metric { Type=MetricType.TextMetric, TextValue = "Very Good!" }, 
     new Metric { Type=MetricType.NumericMetric, NumericValue = 10 } 
    } 
} 

Ora, voglio mappare questo a ad una rappresentazione ViewModel di essa che ha le classi:

public class OrganisationViewModel 
{ 
    public string Name {get;set;} 
    public List<IMetricViewModels> Metrics {get;set;} 
} 

public NumericMetric : IMetricViewModels 
{ 
    public int Value {get;set;} 
} 

public TextMetric : IMetricViewModels 
{ 
    public string Value {get;set;} 
} 

La chiamata a AutoMapper.Map comporterà un OrganisationViewModel contenente un NumericMetric e un TextMetric.

L'Automapper chiamata:

var vm = Automapper.Map<Organisation, OrganisationViewModel>(Org); 

Come potrei fare per Configurazione Automapper a sostegno di questa? È possibile? (Spero che questa domanda sia chiara)

Grazie!

Answer 1

Ok, sto pensando in questo momento il modo migliore per ottenere una cosa del genere sarebbe con un TypeConverter per la parte metrica ... Qualcosa di simile:

AutoMapper.Mapper.Configuration 
     .CreateMap<Organisation, OrganisationViewModel>(); 

AutoMapper.Mapper.Configuration 
     .CreateMap<Metric, IMetricViewModels>() 
     .ConvertUsing<MetricTypeConverter>(); 

Poi il TypeConverter sarebbe qualcosa di simile this:

public class MetricTypeConverter : AutoMapper.TypeConverter<Metric, IMetricViewModel> 
{ 
    protected override IMetricViewModelConvertCore(Metric source) 
    { 
     switch (source.MetricType) 
     { 
      case MetricType.NumericMetric : 
       return new NumericMetric {Value = source.NumericValue}; 

      case MetricType.TextMetric : 
       return new TextMetric {Value = source.StringValue}; 
     } 

    } 
} 

Questo sembra l'approccio giusto qui? Qualche altra guida?