using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp12
{
    public interface ICommand
    {
        Int32 ID { get; set; }
    }

    public interface ICommand<T> : ICommand
    {
        IEnumerable<T> Items { get; set; }
    }

    public class Command : ICommand
    {
        public Int32 ID { get; set; }
    }

    public class Command<T> : Command, ICommand<T>
    {
        public IEnumerable<T> Items { get; set; }
    }

    public interface IItem { }

    public class ItemA : IItem
    {
        public String Name { get; set; }
    }

    public class ItemB : IItem
    {
        public String Name { get; set; }
    }

    public class ItemC : IItem
    {
        public String Name { get; set; }
    }

    public class CommandA : Command<ItemA> { }
    public class CommandB : Command<ItemB> { }
    public class CommandC : Command<ItemC> { }

    public class DTO
    {
        public Int32 IDID { get; set; }
        public String Name { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var sa = new CommandA { ID = 1, Items = new List<ItemA> { new ItemA { Name = "A" }, new ItemA { Name = "B" } } };
            var sb = new CommandB { ID = 2, Items = new List<ItemB> { new ItemB { Name = "C" }, new ItemB { Name = "D" } } };
            var sc = new CommandC { ID = 3, Items = new List<ItemC> { new ItemC { Name = "E" }, new ItemC { Name = "F" } } };

            var config = new MapperConfiguration(x =>
                {
                    x.CreateMap<ICommand, DTO>()
                        .ForMember(d => d.IDID, opt => opt.MapFrom(src => src.ID));

                    x.CreateMap<ItemA, DTO>();
                    x.CreateMap<ItemB, DTO>();
                    x.CreateMap<ItemC, DTO>();

                    x.CreateMap<CommandA, IEnumerable<DTO>>()
                        .ConvertUsing( (src, dst, ctx) =>
                            src.Items.Select(s =>
                            {
                                var x = ctx.Mapper.Map<DTO>(s);
                                return ctx.Mapper.Map(src, x);
                            })
                        );

                    x.CreateMap<CommandB, IEnumerable<DTO>>()
                        .ConvertUsing((src, dst, ctx) =>
                           src.Items.Select(s =>
                           {
                               var x = ctx.Mapper.Map<DTO>(s);
                               return ctx.Mapper.Map(src, x);
                           })
                        );

                    x.CreateMap<CommandC, IEnumerable<DTO>>()
                        .ConvertUsing((src, dst, ctx) =>
                           src.Items.Select(s =>
                           {
                               var x = ctx.Mapper.Map<DTO>(s);
                               return ctx.Mapper.Map(src, x);
                           })
                        );
                }
            );
            var mapper = config.CreateMapper();
            var a = mapper.Map<CommandA, IEnumerable<DTO>>(sa);
            var b = mapper.Map<CommandB, IEnumerable<DTO>>(sb);
            var c = mapper.Map<CommandC, IEnumerable<DTO>>(sc);
            foreach (var x in a)
            {
                Console.WriteLine("{0}, {1}", x.IDID, x.Name);
            }
            foreach (var x in b)
            {
                Console.WriteLine("{0}, {1}", x.IDID, x.Name);
            }
            foreach (var x in c)
            {
                Console.WriteLine("{0}, {1}", x.IDID, x.Name);
            }
            Console.ReadKey();
        }
    }
}

                var config = new MapperConfiguration(x =>
                {
                    x.CreateMap<ICommand, DTO>()
                        .ForMember(d => d.IDID, opt => opt.MapFrom(src => src.ID));

                    x.CreateMap<ItemA, DTO>();
                    x.CreateMap<ItemB, DTO>();
                    x.CreateMap<ItemC, DTO>();

                    x.CreateMap<ICommand<IItem>, IEnumerable<DTO>>()
                        .ConvertUsing((src, dst, ctx) =>
                           src.Items.Select(s =>
                           {
                               var x = ctx.Mapper.Map<DTO>(s);
                               return ctx.Mapper.Map(src, x);
                           })
                        );

                    x.CreateMap<CommandA, IEnumerable<DTO>>();
                    x.CreateMap<CommandB, IEnumerable<DTO>>();
                    x.CreateMap<CommandC, IEnumerable<DTO>>();
                }
            );