namespace AutoMapperVsEfCore

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using AutoMapper;

    using AutoMapper.EquivalencyExpression;

    internal class Program

    {

        private static void Main(string[] args)

        {

            var mapper = CreateMapper();

​

            var container = new Container("Container-Id 000", new List<Item> { new Item("Item-Id 000") { Name = "Item-Name" } });

            var containerModel = mapper.Map<ContainerModel>(container);

            // apply changes

            container.Items[0].Name += " -- changed";

            // update model

            mapper.Map(container, containerModel);

            Console.WriteLine($"Src.Name: {container.Items[0].Name}");

            Console.WriteLine($"Dst.Name: {containerModel.Items[0].Name}");

            if (container.Items[0].Name != containerModel.Items[0].Name)

            {

                throw new InvalidOperationException("The names of dto and model doesn't match!");

            }            

        }

​

        private static IMapper CreateMapper()

        {

            var config = new MapperConfiguration(

                cfg =>

                    {

                        cfg.CreateMap<Container, ContainerModel>(MemberList.None)

                            .EqualityComparison((src, dst) => src.Id == dst.Id)

                            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))

                            .ForMember(dst => dst.Items, opt => opt.MapFrom(src => src.Items));

                        cfg.CreateMap<ContainerModel, Container>(MemberList.None)

                            .EqualityComparison((src, dst) => src.Id == dst.Id)

                            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))

                            .ForMember(dst => dst.Items, opt => opt.MapFrom(src => src.Items));

​

                        cfg.CreateMap<IReadOnlyList<Item>, List<ItemModel>>(MemberList.None)

                            .ConstructUsing((src, ctx) => src.Select(ctx.Mapper.Map<ItemModel>).ToList());

                        cfg.CreateMap<List<ItemModel>, IReadOnlyList<Item>>(MemberList.None)

                            .ConstructUsing((src, ctx) => src.Select(ctx.Mapper.Map<Item>).ToList().AsReadOnly());

​

                        cfg.CreateMap<Item, ItemModel>(MemberList.None)

                            .EqualityComparison((src, dst) => src.Id == dst.Id)

                            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))

                            .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name));

                        cfg.CreateMap<ItemModel, Item>(MemberList.None)

                            .EqualityComparison((src, dst) => src.Id == dst.Id)

                            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))

                            .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name));

                    });

            var result = config.CreateMapper();

            result.ConfigurationProvider.AssertConfigurationIsValid();

            return result;

        }

    }

​

    public class Container

    {

        public Container(string id, IReadOnlyList<Item> items)

        {

            this.Id = id;

            this.Items = items;

        }

​

        public string Id { get; }

​

        public IReadOnlyList<Item> Items { get; }

    }

​

    public class Item

    {

        public Item(string id)

        {

            this.Id = id;

        }

​

        public string Id { get; }

​

        public string Name { get; set; }

    }

​

    public class ContainerModel

    {

        public string Id { get; set; }

​

        public List<ItemModel> Items { get; set; }

    }

​

    public class ItemModel

    {

        public string Id { get; set; }

​

        public string Name { get; set; }

    }

}