Question

We want to generically map from one database’s context.tableType to another
e.g. UatDb.Branch–LiveDb.Branch

The table’s are identical so no MapFrom is necessary.

The following generic mapping definition is sufficient

Mapper.CreateMap<TFromContextTableType,TToContextTableType>();

However!!!

We need to wrap the source context.tableType in the following wrapper class:

public class SWrapper<TFrom> where TFrom : class
{
        public SWrapper(TFrom model)
        {
            Model = model;
        }
        public TFrom Model { get; private set; }
}

Now to perform the mapping we have to map as follows:

Mapper.CreateMap<SWrapper<FromBranchType>, ToBranchType>().ConstructUsing(x => new        Live.Branch()))
.ForMember(d => d.BranchID, o => o.MapFrom(x => x.Model.BranchID))
.ForMember(d => d.BranchName, o => o.MapFrom(x => x.Model.BranchName))
.ForMember(d => d.BranchCountry, o => o.MapFrom(x => x.Model.BranchCountry))

This means that we cannot generically map and have to explicitly declare a ForMember for each mapping. I can’t figure out any solution using Resolvers or Type Converters.

I thought about perhaps wrapping the target in a SWrapper then resolving the returned Wrapped object to return the internal Product but not sure how to perform this.

All ideas welcome….

Answer 1

Taking from your mapping you could do the following which does not require you to enter all of the property mappings by hand. The helper method in the second test allows for specialized mapping that you may not need.

[TestMethod]
public void Given_a_wrapper_class_I_should_be_able_to_unwrap_it_and_continue_with_mappings()
{
    Mapper.CreateMap<Wrapper<Source>, Destination>()
          .UnwrapUsing<Wrapper<Source>, Source, Destination>(w => w.Model)
          .ForMember(d => d.Bar, o => o.MapFrom(d => d.Baz));

    var source = new Source { Baz = 1, Foo = "One" };
    var wrapped = new Wrapper<Source> { Model = source };
    var destination = Mapper.Map<Destination>(wrapped);

    Assert.IsNotNull(destination);
    Assert.AreEqual(1, destination.Bar);
    Assert.AreEqual("One", destination.Foo);
}

public static class AutoMapperExtensions
{
    public static IMappingExpression<TSource, TDest> UnwrapUsing<TWrapper, TSource, TDest>(this IMappingExpression<TWrapper, TDest> expr, Func<Wrapper<TSource>, TSource> unwrapper)
    {
        Mapper.CreateMap<Wrapper<TSource>, TDest>()
              .ConstructUsing(x => Mapper.Map<TSource, TDest>(unwrapper(x)));

        return Mapper.CreateMap<TSource, TDest>();
    }
}

public class Source
{
    public string Foo { get; set; }
    public int Baz { get; set; }
}

public class Destination
{
    public string Foo { get; set; }
    public int Bar { get; set; }
}

public class Wrapper<T>
{
    public T Model { get; set; }
}