AutoMapper扩展

扩展类：AutoMapExtention

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace AutoMapper.Extention
{
    public static class AutoMapExtention
    {
        /// <summary>
        /// 类型映射
        /// </summary>
        /// <typeparam name="F">From</typeparam>
        /// <typeparam name="T">To</typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static T MapTo<F, T>(this F source,
             Func<Dictionary<Expression<Func<T, object>>, Action<IMemberConfigurationExpression<F>>>> mapRuleSets = null,
             bool ignoreNull = false)
            where T : class
            where F : class
        {
            if (source == null) { return default(T); }
            var m = Mapper.CreateMap<F, T>();
            if (ignoreNull)
            {
                m.ForAllMembers(opt => opt.Condition(srs => !srs.IsSourceValueNull));
            }
            if (mapRuleSets != null)
            {
                var arr = mapRuleSets();
                foreach (var item in arr)
                {
                    m.ForMember(item.Key, item.Value);
                }
            }
            return Mapper.Map<T>(source);
        }

        /// <summary>
        /// 集合映射
        /// </summary>
        /// <typeparam name="F"></typeparam>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <param name="defaultValueSets">默认值</param>
        /// <param name="mapRuleSets">映射规则</param>
        /// <returns></returns>
        public static List<T> MapTo<F, T>(this IEnumerable<F> source,
            Func<Dictionary<Expression<Func<T, object>>, Action<IMemberConfigurationExpression<F>>>> mapRuleSets = null,
            bool ignoreNull = false)
            where T : class
            where F : class
        {
            if (source == null) { return new List<T> { }; }
            var m = Mapper.CreateMap<F, T>();
            if (ignoreNull)
            {
                m.ForAllMembers(opt => opt.Condition(srs => !srs.IsSourceValueNull));
            }
            if (mapRuleSets != null)
            {
                var arr = mapRuleSets();
                foreach (var item in arr)
                {
                    m.ForMember(item.Key, item.Value);
                }
            }
            return Mapper.Map<List<T>>(source);
        }
    }
}

实体模型：

using System;

namespace UnitTests.Model.OOMapper
{
    public class User
    {
        public Guid ID { get; set; }
        public int? SerialNumber { get; set; }
        public string RealName { get; set; }
        public bool Sex { get; set; }
    }
}

using System;

namespace UnitTests.Model.OOMapper
{
    public partial class UserDTO
    {
        public Guid ID { get; set; }
        public int? SerialNumber { get; set; }
        public string RealName { get; set; }
        public bool Sex { get; set; }
    }
}

测试

using Microsoft.VisualStudio.TestTools.UnitTesting;
using AutoMapper.Extention;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnitTests.Model.OOMapper;
using System.Linq.Expressions;
using AutoMapper;

namespace UnitTests.Tests
{
    [TestClass()]
    public class OOMapperTests
    {
        [TestMethod()]
        public void MapToTest()
        {
            var user = new User()
            {
                ID = Guid.NewGuid(),
                Sex = true,
                RealName = "陈楚生",
                SerialNumber =
            };
            //单体映射
            var userDTO = user.MapTo<User, UserDTO>(() =>
            {
                var rules = new Dictionary<Expression<Func<UserDTO, object>>, Action<IMemberConfigurationExpression<User>>>();
                rules.Add(dst => dst.RealName, opt => opt.MapFrom(src => string.Format("Hello,{0}", src.RealName)));
                return rules;
            });
            //集合映射
            List<User> users = new List<User>() { user };
            var userDTOs = users.MapTo<User, UserDTO>(() =>
            {
                var rules = new Dictionary<Expression<Func<UserDTO, object>>, Action<IMemberConfigurationExpression<User>>>();
                rules.Add(dst => dst.RealName, opt => opt.MapFrom(src => string.Format("Hello,{0}", src.RealName)));
                return rules;
            });
            Assert.IsTrue(user.ID == userDTO.ID && users.Count == userDTOs.Count);
        }
    }
}