Mapping a property of custom type, inheriting from IEnumerable

[carl-berg]

I have a problem mapping a custom type, that inherits from an interface that in turn inherits from IEnumerable. I am trying to map the property using a resolver, because it has a custom constructor but i keep getting a mapping error when trying to map this. The error goes away if i take away the inheritance to IEnumerable so I assume it has something to do with this.
I have created an issue for this at stack overflow.
My model looks like this:

public interface IMyEnumerable<T> : IEnumerable<T> { }
public class MyIEnumerable<T> : IMyEnumerable<T>
{
    private readonly IEnumerable<T> _items;

    public MyIEnumerable(IEnumerable<T> items)
    {
        _items = items;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _items.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class Source
{
    public List<SourceItem> Items { get; set; }
}

public class Destination
{
    public IMyEnumerable<DestinationItem> Items { get; set; }
}

public class SourceItem
{
    public string Name { get; set; }
}

public class DestinationItem
{
   public string Name { get; set; }
}

My mappings looks like this:

public class MyResolver : ValueResolver<Source, IMyEnumerable<DestinationItem>>
{
    protected override IMyEnumerable<DestinationItem> ResolveCore(Source source)
    {
        var destinationItems = Mapper.Map<IEnumerable<SourceItem>, IEnumerable<DestinationItem>>(source.Items);
        return new MyIEnumerable<DestinationItem>(destinationItems);
    }
}
Mapper.CreateMap<Source, Destination>()
    .ForMember(x => x.Items, m => m.ResolveUsing<MyResolver>());

Mapper.CreateMap<SourceItem, DestinationItem>();

The error i get looks like this:

Mapping types:
MyIEnumerable`1 -> IMyEnumerable`1
MyIEnumerable`1[[DestinationItem]] -> IMyEnumerable`1[[DestinationItem]]

Destination path:
Destination.Items.Items

Source value:
MyIEnumerable`1[DestinationItem]
  ----> System.ArgumentException : Object of type System.Collections.Generic.List`1[DestinationItem] cannot be converted to type IMyEnumerable`1[DestinationItem].

[carl-berg]

With some debugging i can see that the difference between IMyEnumerable<T> : IEnumerable<T> and just IMyEnumerable is that automapper seems to use an EnumerableMapper when the destinationtype inherits from IEnumerable and an AssignableMapper if not. I can see that i get matches both from EnumerableMapper and AssignableMapper when things go wrong, but EnumerableMapper comes first in the list and is chosen because of that...

[jbogard]

Why not use a custom type converter?

[carl-berg]

In my real world problem i have properties of the source object that i need to construct my list, so it's not a clear cut one list to another mapping. Is this still possible with a type converter? If so, could you show me how?

[jbogard]

Can you modify your types to be a bit closer to what you're trying to achieve?

[mwpowellhtx]

I can't speak to how AutoMapper treats to/from type coercion, i.e. treating sources/destinations as IEnumerable, IEnumerable<T>, IList<T>, etc, but I can say that if interesting edge cases are necessary, TypeConverter is pretty simple to work with. You can type-convert as deep or as shallow into the collection/items/members as you need to go, invoking additional mappings as needs be. HTH

[carl-berg]

This is roughly my scenario:

public class Source
{
    public int PageSize { get; set; }
    public int Page { get; set; }
    public string OrderBy { get; set; }
    public bool SortAscending { get; set; }
    public IEnumerable<SourceItem> Items { get; set; }
}

public class Destination
{
    public IMyEnumerable<DestinationItem> Items { get; set; }
}

public class MyEnumerable<T> : IMyEnumerable<T>
{
    public MyEnumerable(T items, int pageSize, int page, string orderBy, bool sortAscending){ ... }
    public int PageSize { get; private set; }
    public int Page { get; private set; }
    public string OrderBy { get; private set; }
    public bool Ascending { get; private set; }

    // .. Enumeration implementation etc ..
}

public interface IMyEnumerable<T> : IEnumerable<T>
{
    int PageSize { get; }
    int Page { get;  }
    string OrderBy { get; }
    bool Ascending { get; }
}

...and there are some more properties that maps between source and destination...

[mwpowellhtx]

It will be more rewarding if you just tried it.

[carl-berg]

I did manage to get something working by doing a mapping like this, which seems acceptable i guess. How would you guys solve this yourselves?

Mapper.CreateMap<Source, Destination>()
      .ForMember(x => x.Items, m => m.MapFrom(x => x));

Mapper.CreateMap<Source, IMyEnumerable<DestinationItem>>()
      .ConvertUsing(x => /* creating my implementation here */);

Mapper.CreateMap<SourceItem, DestinationItem>();

[jbogard]

It's a weird problem, you've got a rearranging of members. I don't know of an easy way to handle this, the names match up but are in different places.

[carl-berg]

OK, I'm satisfied with that though. I just wanted to know if there was an obvious way to handle this that I didn't know about. The destination interface is a common type in our codebase so I created a generic typeconverter for it and with some extension methods and method chaining I've got something I can reuse pretty easily. Thanks for your time and input!

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.