Automapper - reuse of mapping rules for projection

Question

Given 2 source entities:

class SourceA
{
   public string Info1 { get; set; }
   public string Info2 { get; set; }
}

class SourceB
{
   public A A { get; set; }

   public string OptionalExtraInfo { get; set; }
}

and one destination class:

class Dest
{
   public string ModifiedInfo1 { get; set; }
   public string ModifiedInfo2 { get; set; }

   public string ModifiedOptionalExtraInfo { get; set; }
}

I want to have the following code working with EF6:

var destsFromA = dbContext.SourcesA.ProjectTo<Dest>().ToArray();
var destsFromB = dbContext.SourcesB.ProjectTo<Dest>().ToArray();

So I define Automapper.net mappings:

• SourceA => Dest
• SourceB => Dest

with custom rules on how to project Info1 into ModifiedInfo1, and Info2=>ModifiedInfo2:

CreateMap<SourceA, Dest>()
    .ForMember(x => ModifiedInfo1, opt => opt.MapFrom(src => src.Info1 + " something else-1")
    .ForMember(x => ModifiedInfo2, opt => opt.MapFrom(src => src.Info1 + " something else-2")
    .ForMember(x => ModifiedOptionalExtraInfo, opt => opt.Ignore());

CreateMap<SourceB, Dest>()
    .ForMember(x => ModifiedInfo1, opt => opt.MapFrom(src => src.A.Info1 + " something else-1")
    .ForMember(x => ModifiedInfo2, opt => opt.MapFrom(src => src.A.Info2 + " something else-2")
    .ForMember(x => ModifiedOptionalExtraInfo, opt => opt.MapFrom(src => src.OptionalExtraInfo + " something else-3"));

How do I reuse mapping rules for ModifiedInfo1, ModifiedInfo2 in second mapping as they are the same as in the first case?

UPDATE In my certain case I figured out how to reuse SourceA => Dest mapping in a natural way.

First, I added a reverse-reference (navigation property) SourceA.B as these entities are really in one-to-zero-or-one relationship and EF has to know about that.

Then I changed the aggregation root in my application code and it became:

var destsFromA = dbContext.SourcesA.ProjectTo<Dest>().ToArray();
var destsFromB = dbContext.SourcesB.Select(x => x.A).ProjectTo<Dest>().ToArray();

so I only had to work with the only SourceA => Dest mapping

Finally I changed the mapping itself:

CreateMap<SourceA, Dest>()
    .ForMember(x => ModifiedInfo1, opt => opt.MapFrom(src => src.Info1 + " something else-1")
    .ForMember(x => ModifiedInfo2, opt => opt.MapFrom(src => src.Info1 + " something else-2")
    .ForMember(x => ModifiedOptionalExtraInfo, opt => opt.MapFrom(src => src.B ? src.B.OptionalExtraInfo + " something else-3" : null);

As this is a solution to a problem, but not an answer to the original question, I accepted Ilya Chumakov's answer as a correct one.

Answer 1

A quick and easy solution would be to use an intermediate class.

First the classes who are used then later on in the posting

public class SourceA 
{
    public string A { get; set; }
}

public class SourceB
{
    public string B { get; set; }
}

public class Dest
{
    public string ValueFromSourceA { get; set; }

    public string ValueFromSourceB { get; set; }
}

That said here is the intermediate class:

public class Intermediate
{
    public SourceA SourceA { get; set; } = new SourceA();

    public SourceB SourceB { get; set; } = new SourceB();
}

Now let's start sticking the parts together with Automapper.

Defining profile classes

public class DestinationProfile : Profile
{
    public DestinationProfile()
    {
        this.CreateMap<Intermediate, Dest>()
            .ForMember(destination => destination.ValueFromSourceA, 
                       opt => opt.MapFrom(src => src.SourceA.A))
            .ForMember(destination => destination.ValueFromSourceB, 
                       opt => opt.MapFrom(src => src.SourceB.B));
    }
}

public class IntermediateProfile : Profile
{
    public IntermediateProfile()
    {
        this.CreateMap<Intermediate, Dest>()
            .ForMember(destination => destination.ValueFromSourceA, map => map.MapFrom(src => src.SourceA.A))
            .ForMember(destination => destination.ValueFromSourceB, map => map.MapFrom(src => src.SourceB.B));

    // ----- TODO: Create mapping for source classes.
    }
}

And here comes the heavy lifting for the mapping we marked as todo above. You can use IValueResolver interface from Automapper to define value mapping. So in our case the resolvers look like

public class SourceAResolver : IValueResolver<SourceA, Intermediate, SourceA>
{
    public SourceA Resolve(SourceA source, Intermediate destination, SourceA destMember, ResolutionContext context)
    {
        return source;
    }
}

public class SourceBResolver : IValueResolver<SourceB, Intermediate, SourceB>
{
    public SourceB Resolve(SourceB source, Intermediate destination, SourceB destMember, ResolutionContext context)
    {
        return source;
    }
}

With the above now we are able to replace the todo statement

        this.CreateMap<SourceA, Intermediate>()
            .ForMember(destination => destination.SourceA, map => map.ResolveUsing<SourceAResolver>());
        this.CreateMap<SourceB, Intermediate>()
            .ForMember(destination => destination.SourceB, map => map.ResolveUsing<SourceBResolver>());

Finally we register our profile classes to the Automapper

public static class AutomapperProfile
{
    public static void Configure()
    {
        Mapper.Initialize(cfg =>
        {
            cfg.AddProfile<DestinationProfile>();
            cfg.AddProfile<IntermediateProfile>();
        }); 
    }
}

Firing up a console with the below code snippet helps testing our stuff

        AutomapperProfile.Configure();
        var a = new SourceA {A = "Value A"};

        var b = new SourceB() {B = "Value B"};

        var intermediate = new Intermediate() {SourceA = a, SourceB = b};

        var destination = AutoMapper.Mapper.Map<Dest>(intermediate);

        Console.WriteLine(destination.ValueFromSourceA);

        Console.Read();

Done!

Note: The code snippets provided are just coded to demo the usage/meaning of what is meant by "intermediate" class - have not implemented the way back to the source classes.

Have fun with it :)

Answer 2

Parametrize mappings with expressions:

opt.MapFrom(expression)

.ForMember(x => x.Foo, expression)

It's easy to extract these expression variables with ReSharper, so it could look like:

Expression<Func<SourceA, string>> expression = src => src.Info1 + " something else-1";
var func = expression.Compile();

cfg.CreateMap<SourceA, Dest>()
    .ForMember(x => x.ModifiedInfo1, 
        opt => opt.MapFrom(expression));

cfg.CreateMap<SourceB, Dest>()
    .ForMember(x => x.ModifiedInfo1,
        opt => opt.MapFrom(src => func(src.A)));

Update: In case of LINQ to SQL translation, the solution becomes much more complicated. expression.Compile() won't work and a new expression should be created:

Expression<Func<SourceA, string>> expression = src => src.Info1 + "foo";

//it should contain `src => src.A.Info1 + "foo"`
var newExpression = ConvertExpression(expression);

Basic implementation with ExpressionVisitor:

private static Expression<Func<SourceB, string>> 
    ConvertExpression(Expression<Func<SourceA, string>> expression)
{
    var newParam = Expression.Parameter(typeof(SourceB), "src");

    var newExpression = Expression.Lambda<Func<SourceB, string>>(
        new ReplaceVisitor().Modify(expression.Body, newParam), newParam);

    return newExpression;
}    

class ReplaceVisitor : ExpressionVisitor
{
    private ParameterExpression parameter;

    public Expression Modify(Expression expression, ParameterExpression parameter)
    {
        this.parameter = parameter;

        return Visit(expression);
    }

    protected override Expression VisitLambda<T>(Expression<T> node)
    {
        return Expression.Lambda<Func<SourceB, bool>>(
            Visit(node.Body), 
            Expression.Parameter(typeof(SourceB)));
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        if (node.Type == typeof(SourceA))
        {
            return Expression.Property(parameter, nameof(SourceB.A));
        }

        throw new InvalidOperationException();
    }
}