Define mappings with interfaces

[blemasle]

Hi,

According to the documentation, I assumed that mappings defined using interfaces would be applied to derived types. To my surprise, it did not.

Am i doing something wrong ? Is this a bug or is this by design ?
Note it is working if your using base classes instead of interfaces.

See this fiddle.

using AgileObjects.AgileMapper;
using System;
using System.Collections.Generic;

namespace MapperSandbox
{
    class Program
    {
        static void Main(string[] args)
        {
            Mapper
                .WhenMapping
                .From<IA>()
                .To<IB>()
                .Map<ImplementedA>()
                .To<ImplementedB>()
                .And
                .Map((src, dst) => src.Status).To(dst => dst.SomethingUsingStatus);

            var implementB = Mapper.Map(new ImplementedA { Status = 72 }).ToANew<ImplementedB>();
            Console.WriteLine($"Implemented : {implementB.SomethingUsingStatus}");
			
            Mapper
                .WhenMapping
                .From<ABase>()
                .To<BBase>()
                .Map<InheritedA>()
                .To<InheritedB>()
                .And
                .Map((src, dst) => src.Status).To(dst => dst.SomethingUsingStatus);
			
            var inheritedB = Mapper.Map(new InheritedA { Status = 72 }).ToANew<InheritedB>();
            Console.WriteLine($"Inherited : {inheritedB.SomethingUsingStatus}");
        }
    }

    interface IA
    {
        public int Status { get; set; }
    }

    interface IB
    {
        public int SomethingUsingStatus { get; set; }
    }

    class ImplementedA : IA
    {
        public int Status { get; set; }
    }

    class ImplementedB : IB
    {
        public int SomethingUsingStatus { get; set; }
    }
	
    class ABase
    {
        public int Status { get; set; }
    }
	
    class BBase
    {
        public int SomethingUsingStatus { get; set; }
    }
	
    class InheritedA : ABase { }
    class InheritedB : BBase { }
}

Regards

[SteveWilkes]

Hi!

Yep, that's a bug. I'll fix it and get back to you. Thanks for the feedback!

Steve

[SteveWilkes]

This is fixed as of v1.6-preview2, which is now on NuGet.

Thanks again!

Steve

[blemasle]

Perfect! This a great improvement, especially because you do not have to do this anymore

 Mapper
     .WhenMapping
     .From<IA>()
     .To<IB>()
     .Map<ImplementedA>()
     .To<ImplementedB>()

You can now define mappings based solely on interfaces, and they will be picked up by the execution plan.

 Mapper
    .WhenMapping
    .From<IA>()
    .To<IB>();

I think you should add this fact to the documentation once 1.6.0 is released as it provides very flexible and reusable ways of defining mappings.

Thanks for the blazing fast implementation/correction of this issue !

[SteveWilkes]

Great point, thanks! I'll update the documentation when 1.6 is finished :)

Thanks again!

Steve

[blemasle]

The changes you've made introduced a behaviour change but I'm not sure of the actual reason. For instance :

using Microsoft.AspNetCore.JsonPatch;

JsonPatchDocument<A> a = new JsonPatchDocument<A>();
var b = Mapper.Map(a).ToANew<JsonPatchDocument<B>>();

Works fine on preview1 but throws an exception on preview2
No coercion operator is defined between types 'Microsoft.AspNetCore.JsonPatch.JsonPatchDocument``1[MapperSandbox.B]' and 'Newtonsoft.Json.Serialization.DefaultContractResolver'.'

In this use case, there is no specific mapping defined and I'm only relying on implicit, name based mappings.

[SteveWilkes]

Oh! Must be a hole in my tests somewhere - I'll check it out and report back.

Cheers!

Steve

[SteveWilkes]

Hello again!

I've just uploaded v1.6 preview3 to NuGet, which behaves like preview 1 with respect to the JsonPatchDocument issue, and preview 2 with respect to type pairing using interfaces. Let me know how you get on!

All the best,

Steve

[blemasle]

Hi,

Sorry for the delay. I can confirm that both my (slightly more complicated) use cases are working now.

Thank you!

[SteveWilkes]

These fixes are included in v1.6, which is now available on NuGet.

Thanks again for the feedback!