Map encapsulated property to IEnumerable

Question

Given the following classes

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

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

public class Foos : IEnumerable<Foo> {
    private IList<Foo> _foos;

    public Foos(int max = 10)
    {
        _foos = Enumerable.Range(0, max)
            .Select(i => new Foo() { Name = "Foo" + i})
            .ToList();
    }

    public IEnumerator<Foo> GetEnumerator()
    {
        return _foos.GetEnumerator();
    }

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

and the following mapping:

Mapper.CreateMap<Foo, Bar>();

I can map Foos to IEnumerable<Bar> with:

Mapper.Map<IEnumerable<Bar>>(new Foos(5));

But, if I have an additional class that looks like this:

public class FooContainer {
    private Foos _foos;

    public FooContainer()
    {
        _foos = new Foos(5);
    }

    public Foos Foos { get { return _foos; } }
}

How would I set up a mapping so that FooContainer maps to IEnumerable<Bar>?

Edit

OK, just to clarify the question - if I've got the following three classes:

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

public class Bar {
    public Guid SourceId { get; set; }
    public string Name { get; set; }
}

public class FooContainer {
    public Guid Id { get; set; }
    public List<Foo> Foos { get; set; }
}

how do I set up a mapping for FooContainer to IEnumerable<Bar> such that FooContainer.Id maps to each Bar.SourceId and Foo.Name maps to Bar.Name?

Does `Mapper.Map, IEnumerable>(fooContainer.Foos);` not work? — Dustin Kingen, Oct 14 '13 at 11:28
Absolutely given that this is a simplified example. However, I will have other properties on `FooContainer` that I will apply to the Bar instances using an `AfterMap` if at all possible. — Ed Courtenay, Oct 14 '13 at 12:00
You might want to implement an [`ITypeConverter`](https://github.com/AutoMapper/AutoMapper/wiki/Custom-type-converters). — Dustin Kingen, Oct 14 '13 at 12:03

Dustin Kingen · Accepted Answer · 2013-10-14T14:21:10.193

For complex logic you can implement an ITypeConverter.

public class FooContainerTypeConverter
    : ITypeConverter<FooContainer, IEnumerable<Bar>>
{
    public IEnumerable<Bar> Convert(ResolutionContext context)
    {
        var source = context.SourceValue as FooContainer;

        if(source == null)
        {
            return Enumerable.Empty<Bar>();
        }

        var result = source.Foos.Select(foo => MapBar(foo, source.Id));
        return result;
    }

    private static Bar MapBar(Foo item, Guid id)
    {
        // Use the existing Foo => Bar mapping
        var bar = Mapper.Map<Foo,Bar>(item);
        bar.Id = id;
        return bar;
    }
}

Usage:

Mapper.CreateMap<FooContainer, IEnumerable<Bar>>()
      .ConvertUsing<FooContainerTypeConverter>();

Thanks @Romoku, I see where you're going with the `ITypeConverter`. If you fix up the example (unless I'm missing something, there's no `AfterMap` extension method valid after the `Map` call) I'll mark as the answer. — Ed Courtenay, Oct 14 '13 at 14:15

Map encapsulated property to IEnumerable

1 Answers1