Automapper resolver el tipo de destino basado en el valor de una enumeración en el tipo de fuente

Question

Estoy tratando de encontrar una manera para Automapper para elegir el tipo de destino de una llamada al mapa, basado en un valor Enum establecido en el tipo Fuente.

Por ej. Dadas las siguientes clases:

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 
} 

Si tengo el siguiente objeto:

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 } 
    } 
} 

Ahora, yo quiero para mapear esto a una representación modelo de vista de la misma que tiene las clases:

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 llamada a AutoMapper.Map dará como resultado un OrganisationViewModel que contiene un NumericMetric y un TextMetric.

El AutoMapper llamada:

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

¿Cómo hago para configurar AutoMapper para apoyar esto? es posible? (Espero que esta pregunta es clara)

Gracias!

Answer 1

Ok, estoy pensando en este momento la mejor manera de lograr tal cosa sería con un TypeConverter para la parte métrica ... Algo así como:

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

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

Entonces el TypeConverter sería algo como esto:

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

    } 
} 

¿Esto parece el enfoque correcto aquí? ¿Alguna otra guía?