我如何使用 Automapper 在两个枚举之间进行 map？

Question

I have a public facing interface that I'm trying to map two different enumerations to each other. I tried to use the following code:

Mapper.CreateMap<Contract_1_1_0.ValidationResultType, Common.ValidationResultType>();

When that didn't work, I tried:

Mapper.CreateMap<Contract_1_1_0.ValidationResultType, Common.ValidationResultType>().ConvertUsing(x => (Common.ValidationResultType)((int)x));

But that doesn't seem to work either. Is there anyway to get automapper to handle this scenario?

Answer 1

Alternatively to writing custom converters, just use ConvertUsing()

Mapper.CreateMap<EnumSrc, EnumDst>().ConvertUsing(value => 
{
    switch(value)
    {
        case EnumSrc.Option1:
            return EnumDst.Choice1;
        case EnumSrc.Option2:
            return EnumDst.Choice2;
        case EnumSrc.Option3:
            return EnumDst.Choice3;
        default:
            return EnumDst.None;
    }
});

Answer 2

You don't need to do CreateMap for enum types. Just get rid of the CreateMap call and it should work, as long as the names and/or values match up between enum types.

Answer 3

My Automapper works this way:

If I create a map: Automapper will match enums by value, even if name match perfectly.

If I do not create a map: Automapper will match enums by name.

Answer 4

The Simplest Way I found that work for me is as below:

My Enum is a nested in another class so I Use ForMember method and MapFrom as below:

 Mapper.CreateMap<ProblematicCustomer, ProblematicCustomerViewModel>()                
            .ForMember(m=> m.ProblemType, opt=> opt.MapFrom(x=> (ProblemTypeViewModel)(int)x.ProblemType))
            .ForMember(m=> m.JudgmentType, opt=> opt.MapFrom(x=> (JudgmentTypeViewModel)(int)x.JudgmentType));

The ProblemType and JudgmentType are Enums. And their related View Models are ProblemTypeViewModel and JudgmentTypeViewModel with same members as their related Models.

Although I don't test, But I think below line should work for you:

Mapper.CreateMap<Contract_1_1_0.ValidationResultType, Common.ValidationResultType>()
           .ForMember(m=> m, opt => opt.MapFrom(x=> (Common.ValidationResultType)(int)x);

Hope it Help.

Answer 5

The other answers here didn't work for me.

You need to create a class that implements:

ITypeConvertor<SourceType ,DestinationType>

So as an example

 Mapper.CreateMap<EnumType1.VatLevel, EnumType2.VatRateLevel>()
       .ConvertUsing(new VatLevelConvertor());

And the class:

internal class VatLevelConvertor : ITypeConverter<EnumType1.VatLevel, EnumType2.VatRateLevel>
{
    public EnumType2.VatRateLevel Convert(ResolutionContext context)
    {
        EnumType1.VatLevel value = (EnumType1.VatLevel)context.SourceValue;
        switch (value)
        {
            case EnumType1.VatLevel.Standard:
                return EnumType2.VatRateLevel.Normal;
            case EnumType1.VatLevel.Reduced:
                return EnumType2.VatRateLevel.Lower;
            case EnumType1.VatLevel.SuperReduced:
                return EnumType2.VatRateLevel.Other;
            default:
                return EnumType2.VatRateLevel.Other;
        }
    }
}

Answer 6

Here's one possibility for making a conversion between two Enum types that both have different values, while still using AutoMapper. In my case, I needed to use AutoMapper because the Enum types were properties on other entities being converted by AutoMapper; using AutoMapper for these entities was a requirement.

The first step is to setup the Mapper configuration like so:

Mapper.CreateMap<EnumSrc, EnumDst>()
    .ConstructUsing(EnumConversion.FromSrcToDst);

Calling .ConstructUsing(...) allows us to pass in our own method for making the conversion. The method for conversion is pretty straight forward:

public class EnumConversion
{
    internal static EnumDst FromSrcToDst(ResolutionContext arg)
    {
        EnumSrc value = (EnumSrc)arg.SourceValue;
        switch(value)
        {
            case EnumSrc.Option1:
                return EnumDst.Choice1;
            case EnumSrc.Option2:
                return EnumDst.Choice2;
            case EnumSrc.Option3:
                return EnumDst.Choice3;
            default:
                return EnumDst.None;
        }
    }
}

We simply switch through the values of the source Enum and return the appropriate destination Enum value arbitrarily. AutoMapper takes care of the rest.

Answer 7

Just create a mapper for two Enums, that's it! Automapper will map by the either the matching value or index value of the Enum. (eg Draft -> Step1)

public enum SourceStatus
{
    Draft,
    Submitted,
    Deleted
}

public enum DestinationStatus
{
    Step1,
    Step2,
    Step3
}

public class SourceObj
{
    public SourceStatus Status { get; set; }
}

public class DestinationObj
{
    public DestinationStatus Status { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        //Static APi style - this is obsolete now. From Version 5.0 onwards    this will be removed.
        SourceObj mySrcObj = new SourceObj();
        mySrcObj.Status = SourceStatus.Deleted;

        Mapper.CreateMap<SourceStatus, DestinationStatus>();
        Mapper.CreateMap<SourceObj, DestinationObj>();

        DestinationObj myDestObj = Mapper.Map<SourceObj, DestinationObj>(mySrcObj);

        //New way of doing it
        SourceObj mySrcObj2 = new SourceObj();
        mySrcObj2.Status = SourceStatus.Draft;

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

        IMapper mapper = config.CreateMapper();
        var source = new SourceObj();
        var dest = mapper.Map<SourceObj, DestinationObj>(source);



    }
}

Answer 8

I was trying to map between "equal" enums using Automapper, but unfortunately it didn't work. I suspect the problem is a difference in casing:

public enum Foo {
    val1,
    val2
}

public enum Bar {
    Val1,
    Val2
}

Foo is something auto-generated from an XSD, and the supplier sucks. Also there are thirty-something values and I didn't want to put a switch that large anywhere for something so silly.

The approach I took was to convert the source value to string and parse that as the destination value:

static Foo ConvertEnum(Bar source)
{
    Foo result;
    var parsed = Enum.TryParse(source.ToString().ToLowerInvariant(), true, out result);
    if(!parsed)
         // throw or return default value
         throw new ArgumentOutOfRangeException("source", source, "Unknown source value");
    return result;
}

Of course, this only works if your enums only have differences in casing. You could make it more elaborate by cleaning up the input string (eg remove underscores etc.) or by adding stuff to it as required.

Answer 9

I know this question is old but if some people like me pass by here...

From the AutoMapper documentation there's now a AutoMapper.Extensions.EnumMapping Nuget package providing a simple way to do it.

Quote from the AutoMapper documentation:

public enum Source
{
    Default = 0,
    First = 1,
    Second = 2
}

public enum Destination
{
    Default = 0,
    Second = 2
}

internal class YourProfile : Profile
{
    public YourProfile()
    {
        CreateMap<Source, Destination>()
            .ConvertUsingEnumMapping(opt => opt
                // optional: .MapByValue() or MapByName(), without configuration MapByValue is used
                .MapValue(Source.First, Destination.Default)
            )
            .ReverseMap(); // to support Destination to Source mapping, including custom mappings of ConvertUsingEnumMapping
    }
}

Answer 10

I know this is a very old topic, but it's the main one I get when googling, so decided to show my findings.

I have source and destination enums. They don't fully match, but sometimes there might be an overlap of the value (the numeric one), but that match might not be correct. To illustrate, here are 2 enums:

enum EnumA {
  Item1 = 5,
  Item2 = 10,
  Item3 = 15
}

enum EnumB {
  I1 = 15,
  I2 = 10,
  I3 = 5
}

I wanted to have an explicit map between the two, so I have a switch case like this:

source switch {
  EnumA.Item1 => EnumB.I1,
  EnumA.Item2 => EnumB.I2,
  EnumA.Item3 => EnumB.I3,
  _ => throw new ArgumentException("")
}

So far, so good, this works as expected. The interesting part comes when I tried to hook it to AutoMapper.

I've defined a mapping like this

CreateMap<EnumA, EnumB>().ConvertUsing((src, dest) => src switch {
  EnumA.Item1 => EnumB.I1,
  EnumA.Item2 => EnumB.I2,
  EnumA.Item3 => EnumB.I3,
  _ => throw new ArgumentException("")
});

And then used it as a regular member map

.ForMember(dest => dest.PropA, opts => opts.MapFrom(src => src.PropB))

With this code however, when there is a match of the number ids, I would get the wrong enum member.

The only way I could make it work was to defined a value converter

public class ItemConverter : IValueConverter<EnumA, EnumB>
{
  public CountryCode Convert(EnumA sourceMember, ResolutionContext context) => sourceMember switch
  {
    EnumA.Item1 => EnumB.I1,
    EnumA.Item2 => EnumB.I2,
    EnumA.Item3 => EnumB.I3,
    _ => throw new ArgumentException("")
  }
}

And use it like this:

.ForMember(dest => dest.PropA, opts => opts.ConvertUsing(new ItemConverter(), src => src.PropB))

Hope it helps someone like me in the future