c# 映射对比测试

c#  映射对比测试（测试对象，测试案例，测试结果）

测试组件对象：

TinyMapper-EmitMapper-AutoMapper-NLiteMapper-Handwritten

对比测试案例：

类：Models

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
   public  class Models
    {
        public class Person
        {
            public Guid Id { get; set; }
            public String Name { get; set; }
            public Int32 Age { get; set; }
            public Address Address { get; set; }
            public string Number { get; set; }
        }
        public class PersonDto
        {
            public Guid Id { get; set; }
            public String UserName { get; set; }
            public Int32 Age { get; set; }
            public Address Address { get; set; }
            public string Number { get; set; }
        }

        public sealed class Address
        {
            public string Phone { get; set; }
            public string Street { get; set; }
            public string ZipCode { get; set; }
        }
    }
}

类：CodeTimer

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    public sealed class CodeTimer
    {
        public static void Initialize()
        {
            Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
            Thread.CurrentThread.Priority = ThreadPriority.Highest;
            Time("", 1, () => { });
        }

        public static void Time(string name, Action action)
        {
            Time(name, 1, action);
        }

        public static void Time(string name, int iteration, Action action)
        {
            if (String.IsNullOrEmpty(name)) return;

            // 1.
            ConsoleColor currentForeColor = Console.ForegroundColor;
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(name);

            // 2.
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            int[] gcCounts = new int[GC.MaxGeneration + 1];
            for (int i = 0; i <= GC.MaxGeneration; i++)
            {
                gcCounts[i] = GC.CollectionCount(i);
            }

            // 3.
            Stopwatch watch = new Stopwatch();
            watch.Start();
            long cycleCount = GetCycleCount();
            for (int i = 0; i < iteration; i++) action();
            long cpuCycles = GetCycleCount() - cycleCount;
            watch.Stop();

            // 4.
            Console.ForegroundColor = currentForeColor;
            Console.WriteLine("	Time Elapsed:	" + watch.ElapsedMilliseconds.ToString("N0") + "ms");
            Console.WriteLine("	CPU Cycles:	" + cpuCycles.ToString("N0"));

            // 5.
            for (int i = 0; i <= GC.MaxGeneration; i++)
            {
                int count = GC.CollectionCount(i) - gcCounts[i];
                Console.WriteLine("	Gen " + i + ": 		" + count);
            }

            Console.WriteLine();

        }

        private static long GetCycleCount()
        {
            return GetCurrentThreadTimes();
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool GetThreadTimes(IntPtr hThread, out long lpCreationTime,
           out long lpExitTime, out long lpKernelTime, out long lpUserTime);

        private static long GetCurrentThreadTimes()
        {
            long l;
            long kernelTime, userTimer;
            GetThreadTimes(GetCurrentThread(), out l, out l, out kernelTime,
               out userTimer);
            return kernelTime + userTimer;
        }

        [DllImport("kernel32.dll")]
        static extern IntPtr GetCurrentThread();
    }
}

类：Program

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Nelibur.ObjectMapper;//安装TinyMapper
using Nelibur.ObjectMapper.Bindings;
using EmitMapper;//安装EmitMapper
using AutoMapper;//安装AutoMapper
using NLite;
using EmitMapper.MappingConfiguration;
using System.Reflection;//安装NLite

namespace ConsoleApplication1
{
    public class Program : Models
    {
        protected static List<Person> _person;
        protected static List<PersonDto> _personDto;

        static void Main(string[] args)
        {
            Base();
            //进行测试 测试次数1次
            CodeTimer.Time("--TinyMapper--测试", 1, () => Test1());
            CodeTimer.Time("--EmitMapper--测试", 1, () => Test2());
            CodeTimer.Time("--AutoMapper--测试", 1, () => Test3());
            CodeTimer.Time("--NLiteMapper--测试", 1, () => Test4());
            CodeTimer.Time("--Handwritten--测试", 1, () => Test5());
            ConsoleColor currentForeColor = Console.ForegroundColor;
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("任务完成");
            Console.ReadKey();
        }

        #region 初始化数据
        public static void Base()
        {
            _person = new List<Person>();

            for (int i = 0; i < 1000000; i++)
            {
                Person _per = new Person()
                {
                    Id = Guid.NewGuid(),
                    Name = "老黑",
                    Age = 22,
                    Address = new Address
                    {
                        Phone = "18772871387",
                        Street = "小红门",
                        ZipCode = "邮编未知",
                    },
                    Number = "123456789"
                };
                _person.Add(_per);
            }
        }
        #endregion

        #region TinyMapper映射
        static void Test1()
        {
            //TinyMapper.Bind<Person,PersonDto>();
            //_personDto = TinyMapper.Map<List<PersonDto>>(_person);
            TinyMapper.Bind<Person, PersonDto>(config =>
            {
                config.Bind(x => x.Id, y => y.Id);
                config.Bind(x => x.Name, y => y.UserName);
                config.Bind(x => x.Age, y => y.Age);
                config.Bind(x => x.Address.Phone, y => y.Address.Phone);
                config.Bind(x => x.Address.Street, y => y.Address.Street);
                config.Bind(x => x.Address.ZipCode, y => y.Address.ZipCode);
                config.Bind(x => x.Number, y => y.Number);
            });
            _personDto = TinyMapper.Map<List<PersonDto>>(_person);
        }
        #endregion

        #region EmitMapper 映射
        static void Test2()
        {
            _personDto.Clear();
            //EmitMapper.ObjectsMapper<List<Person>, List<PersonDto>> mapper = ObjectMapperManager.DefaultInstance.GetMapper<List<Person>, List<PersonDto>>();
            //_personDto = mapper.Map(_person);
            EmitMapper.ObjectsMapper<List<Person>, List<PersonDto>> mapper;
            mapper = ObjectMapperManager.DefaultInstance.GetMapper<List<Person>, List<PersonDto>>(new DefaultMapConfig()
               .ConvertUsing<Person, PersonDto>(value => new PersonDto
               {
                   Id = value.Id,
                   UserName = value.Name,
                   Age = value.Age,
                   Address = new Address()
                   {
                       Phone = value.Address.Phone,
                       Street = value.Address.Street,
                       ZipCode = value.Address.ZipCode,
                   },
                   Number = value.Number
               })
                );
            _personDto = mapper.Map(_person);
        }
        #endregion

        #region AutoMapper 映射
        static void Test3()
        {
            _personDto.Clear();
            //AutoMapper.Mapper.CreateMap<Person,PersonDto>();
            //_personDto = AutoMapper.Mapper.Map<List<PersonDto>>(_person);


            AutoMapper.Mapper.CreateMap<Person, PersonDto>()
                .ConstructUsing(value => new PersonDto
                {
                    Id = value.Id,
                    UserName = value.Name,
                    Age = value.Age,
                    Address = new Address()
                    {
                        Phone = value.Address.Phone,
                        Street = value.Address.Street,
                        ZipCode = value.Address.ZipCode,
                    },
                    Number = value.Number
                });
            _personDto = AutoMapper.Mapper.Map<List<PersonDto>>(_person);
        }
        #endregion

        #region NLiteMapper 映射
        static void Test4()
        {
            _personDto.Clear();
            //NLite.Mapping.IMapper<List<Person>, List<PersonDto>> mapper = NLite.Mapper.CreateMapper<List<Person>, List<PersonDto>>();
            //_personDto = mapper.Map(_person);
            NLite.Mapping.IMapper<List<Person>, List<PersonDto>> mapper;
            mapper = NLite.Mapper.CreateMapper<List<Person>, List<PersonDto>>()
            .ConvertUsing<Person, PersonDto>(v => new PersonDto
            {
                Id = v.Id,
                UserName = v.Name,
                Age = v.Age,
                Address = new Address()
                {
                    Phone = v.Address.Phone,
                    Street = v.Address.Street,
                    ZipCode = v.Address.ZipCode,
                },
                Number = v.Number
            });
            _personDto = mapper.Map(_person);
        }
        #endregion
        #region Handwritten 手工映射
        static void Test5()
        {
            _personDto.Clear();
            _personDto = new List<PersonDto>();
            PersonDto p = new PersonDto();
            for (int i = 0; i < _person.Count; i++)
            {
                p.Id = _person[i].Id;
                p.UserName = _person[i].Name;
                p.Age = _person[i].Age;
                p.Address = _person[i].Address;
                p.Number = _person[i].Number;
                _personDto.Add(p);
            }
        }
        #endregion

对比测试结果截图：