备案控制台
开发者社区 开发与运维 文章 正文

Green.AgileMapper项目-新增DO和DTO代码生成

2017-11-08 650
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

    如果你还不了解Green.AgileMapper的用意，作用请先一步到上篇Green.AgileMapper开源项目的使用，如果你觉得运行时（Runtime）的Mapper效率存在问题，在这个版本中有了更新，新增了C#直接代码的生成，这里的生成都已3.0后的扩展方法实现，你可以很方便的一句代码实现两者的转化。

    代码生成我本想利用T4模板，但是由于我们的项目IDE版本是VS2008，对于T4的参数传递支持还不是很友好，你可能说用AppDomain.SetData,或者CallContext.LogicalSetData，但是可惜我们的饿MappingRule是不可序列化的，所以最后我只得采用了字符串拼接最笨的办法，为了应对生成策略不同，在这里我们加入了策略模式来应付，来看看代码结构吧：

image

   在这里只支持对do的二级属性映射为dto的平面属性，全部针对IMappingRule生成代码，在这里为了生成合法的代码而非表达式，对以前的表达式进行了重新的标准约定，在代码注释。以及对上个版本的List转换进行了多次重载，主要为了满足DTo到DO对象的特殊要求，因为我们在领域开发存储DTO的时候都是需要先取出DO对象在根据DTO在DO对象的基础上进行修改，以便ORM领域框架或者UOW的跟踪记录。

下面看看任然是上个测试类模型的代码生成（在这里测试DO，DTO类进行了重构为了更全面的测试，具体请看CodePlex http://agilemapper.codeplex.com/代码）：

StudenDo stu = new StudenDo() 
          { 
              ID = 1, 
              Name = "test1", 
              Sex = Sex.女, 
              Address = new Address() 
              { 
                  Country = "中国", 
                  Province = "四川", 
                  Street = "高新区" 
              }, 
              CourseIds = new List<string>() { "1", "2", "3" }, 
              Propertys = new List<KeyValuePair>() { new KeyValuePair() { Key = "1", Value = "1" } }, 
              ContactWay = new ContactWay() 
              { 
                  Phone = "1111111111111111", 
                  Email = "xxxx@12f", 
                  QQ = "7889789999889" 
              } 
          }; 
          Func<StudenDo, StudenDo, bool> fun = (f, j) =&gt; f.ID == j.ID; 
          var s = fun.ToString();

          var mapper = ObjectMapperManager.Default.GetMapper<StudenDto, StudenDo>(); 
          mapper.AgileMapperTemplateStrategy.DefaultEqualExpression = "{0}.ID == {1}.ID && {1}.ID != 0";                  
          var str1 = mapper.CodeGenerator(); 
          System.IO.File.Delete(@"E:\Project\OpenSource\AgileMapper\AgileMappper.Test\CodeTemplate.Test\1.cs"); 
          System.IO.File.AppendAllText(@"E:\Project\OpenSource\AgileMapper\AgileMappper.Test\CodeTemplate.Test\1.cs", str1);

          var mapper1 = ObjectMapperManager.Default.GetMapper<ContactWayDto, ContactWay>();                    
          str1 = mapper1.CodeGenerator(); 
          System.IO.File.Delete(@"E:\Project\OpenSource\AgileMapper\AgileMappper.Test\CodeTemplate.Test\2.cs"); 
          System.IO.File.AppendAllText(@"E:\Project\OpenSource\AgileMapper\AgileMappper.Test\CodeTemplate.Test\2.cs", str1);

          var mapper2 = ObjectMapperManager.Default.GetMapper<KeyValuePairDto, KeyValuePair>();            
          str1 = mapper2.CodeGenerator(); 
          System.IO.File.Delete(@"E:\Project\OpenSource\AgileMapper\AgileMappper.Test\CodeTemplate.Test\3.cs"); 
          System.IO.File.AppendAllText(@"E:\Project\OpenSource\AgileMapper\AgileMappper.Test\CodeTemplate.Test\3.cs", str1);

最后的生成文件：

1.cs:

using System; 
using System.Linq; 
using System.Data; 
using System.Collections.Generic;

namespace Green.AgileMapper 
{ 
    public static partial class AgileMapperMapping 
    { 
        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto  Warp fromObj Green.AgileMapper.Test.StudenDo; 
        /// </summary> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo</param> 
        /// <returns>Green.AgileMapper.Test.StudenDto</returns> 
        public static Green.AgileMapper.Test.StudenDto Warp(this Green.AgileMapper.Test.StudenDo domainObj) 
        { 
            var fromObj = new Green.AgileMapper.Test.StudenDto(); 
            fromObj.ID = domainObj.ID; 
            fromObj.Name = domainObj.Name; 
            fromObj.Sex = domainObj.Sex; 
            if (domainObj.Address != null) 
            { 
                fromObj.Country = domainObj.Address.Country; 
                fromObj.Province = domainObj.Address.Province; 
            } 
            fromObj.Particular = domainObj.Address.Country + " 国籍 " + domainObj.Address.Province + " 省 "; 
            fromObj.FirstPropertyKey = domainObj.Propertys[0].Key; 
            if (domainObj.ContactWay != null) 
            { 
                fromObj.ContactWay = domainObj.ContactWay.Warp(); 
            } 
            if (domainObj.CourseIds != null) 
            { 
                fromObj.CourseIds = new List<System.String>(); 
                foreach (var item_CourseIds in domainObj.CourseIds) 
                { 
                    fromObj.CourseIds.Add(item_CourseIds); 
                } 
            } 
            if (domainObj.Propertys != null) 
            { 
                fromObj.Propertys = domainObj.Propertys.Warp(); 
            } 
            return fromObj; 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto  Warp domainObj Green.AgileMapper.Test.StudenDo; 
        /// </summary> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo</param> 
        /// <returns>fromObj</returns> 
        public static void Warp(this Green.AgileMapper.Test.StudenDto fromObj, Green.AgileMapper.Test.StudenDo domainObj) 
        { 
            if (fromObj == null) 
            { 
                return; 
            } 
            if (domainObj == null) 
            { 
                domainObj = new Green.AgileMapper.Test.StudenDo(); 
            } 
            domainObj.ID = fromObj.ID; 
            domainObj.Name = fromObj.Name; 
            domainObj.Sex = fromObj.Sex; 
            if (domainObj.Address == null) 
            { 
                domainObj.Address = new Green.AgileMapper.Test.Address(); 
            } 
            domainObj.Address.Country = fromObj.Country; 
            domainObj.Address.Province = fromObj.Province;

            if (domainObj.ContactWay == null) 
            { 
                domainObj.ContactWay = new Green.AgileMapper.Test.ContactWay(); 
            } 
            fromObj.ContactWay.Warp(domainObj.ContactWay); 
            if (fromObj.CourseIds != null) 
            { 
                if (domainObj.CourseIds == null) 
                { 
                    domainObj.CourseIds = new List<System.String>(); 
                } 
                domainObj.CourseIds.Clear(); 
                foreach (var item_CourseIds in fromObj.CourseIds) 
                { 
                    domainObj.CourseIds.Add(item_CourseIds); 
                } 
            } 
            if (fromObj.Propertys != null) 
            { 
                if (domainObj.Propertys == null) 
                { 
                    domainObj.Propertys = new List<Green.AgileMapper.Test.KeyValuePair>(); 
                } 
                fromObj.Propertys.Warp(domainObj.Propertys, (fromObjItem, domainObjItem) =&gt; fromObjItem.Key == domainObjItem.Key, true); 
            }

        }

        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto collection Warp fromObj Green.AgileMapper.Test.StudenDo collection; 
        /// </summary> 
        /// <param name="form">Green.AgileMapper.Test.StudenDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo collection</param>        
        public static List<Green.AgileMapper.Test.StudenDto> Warp(this IList<Green.AgileMapper.Test.StudenDo> domainObj) 
        { 
            List<Green.AgileMapper.Test.StudenDto> froms = new List<Green.AgileMapper.Test.StudenDto>(); 
            domainObj.ToList().ForEach(t =&gt; 
            { 
                froms.Add(Warp(t)); 
            }); 
            return froms; 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto collection Warp domainObj Green.AgileMapper.Test.StudenDo collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.StudenDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo collection</param>      
        public static void Warp(this IList<Green.AgileMapper.Test.StudenDto> fromObj, IList<Green.AgileMapper.Test.StudenDo> domainObj) 
        { 
            fromObj.Warp(domainObj, (fromObjItem, domainObjItem) =&gt; fromObjItem.ID == domainObjItem.ID && domainObjItem.ID != 0, false); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto collection Warp domainObj Green.AgileMapper.Test.StudenDo collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.StudenDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo collection</param> 
        /// <param name="isDeleteNotInFromItem">Delete the item that not in From collection</param>           
        public static void Warp(this IList<Green.AgileMapper.Test.StudenDto> fromObj, IList<Green.AgileMapper.Test.StudenDo> domainObj, bool isDeleteNotInFromItem) 
        { 
            fromObj.Warp(domainObj, (fromObjItem, domainObjItem) =&gt; fromObjItem.ID == domainObjItem.ID && domainObjItem.ID != 0, isDeleteNotInFromItem); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto collection Warp domainObj Green.AgileMapper.Test.StudenDo collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.StudenDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo collection</param> 
        /// <param name="equalPredicate">the from item equal to item expression</param>           
        public static void Warp(this IList<Green.AgileMapper.Test.StudenDto> fromObj, IList<Green.AgileMapper.Test.StudenDo> domainObj, Func<Green.AgileMapper.Test.StudenDto, Green.AgileMapper.Test.StudenDo, bool> equalPredicate) 
        { 
            fromObj.Warp(domainObj, equalPredicate, false); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.StudenDto collection Warp domainObj Green.AgileMapper.Test.StudenDo collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.StudenDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.StudenDo collection</param> 
        /// <param name="equalPredicate">the from item equal to item expression</param>      
        /// <param name="isDeleteNotInFromItem">Delete the item that not in From collection</param>     
        public static void Warp(this IList<Green.AgileMapper.Test.StudenDto> fromObj, IList<Green.AgileMapper.Test.StudenDo> domainObj, Func<Green.AgileMapper.Test.StudenDto, Green.AgileMapper.Test.StudenDo, bool> equalPredicate, bool isDeleteNotInFromItem) 
        { 
            if (fromObj == null) 
            { 
                return; 
            }

            if (domainObj == null) 
            { 
                domainObj = new List<Green.AgileMapper.Test.StudenDo>(); 
            }

            fromObj.ToList().ForEach(fromObjItem =&gt; 
            { 
                Green.AgileMapper.Test.StudenDo toItem = default(Green.AgileMapper.Test.StudenDo); 
                if (equalPredicate != null) 
                { 
                    toItem = domainObj.SingleOrDefault(domainObjItem =&gt; equalPredicate(fromObjItem, domainObjItem)); 
                } 
                if (toItem == null) 
                { 
                    toItem = new Green.AgileMapper.Test.StudenDo(); 
                    domainObj.Add(toItem); 
                } 
                Warp(fromObjItem, toItem); 
            });

            if (isDeleteNotInFromItem) 
            { 
                domainObj.Where(domainObjItem =&gt; fromObj.FirstOrDefault(fromObjItem =&gt; equalPredicate(fromObjItem, domainObjItem)) == null) 
                    .ToList().ForEach(t =&gt; 
                    { 
                        domainObj.Remove(t); 
                    }); 
            } 
        } 
    } 
}

 

2.cs

using System; 
using System.Linq; 
using System.Data; 
using System.Collections.Generic;

namespace Green.AgileMapper 
{ 
    public static partial class AgileMapperMapping 
    { 
        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto  Warp fromObj Green.AgileMapper.Test.ContactWay; 
        /// </summary> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay</param> 
        /// <returns>Green.AgileMapper.Test.ContactWayDto</returns> 
        public static Green.AgileMapper.Test.ContactWayDto Warp(this Green.AgileMapper.Test.ContactWay domainObj) 
        { 
            var fromObj = new Green.AgileMapper.Test.ContactWayDto(); 
            fromObj.Phone = domainObj.Phone; 
            fromObj.Email = domainObj.Email; 
            fromObj.QQ = domainObj.QQ; 
            return fromObj; 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto  Warp domainObj Green.AgileMapper.Test.ContactWay; 
        /// </summary> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay</param> 
        /// <returns>fromObj</returns> 
        public static void Warp(this Green.AgileMapper.Test.ContactWayDto fromObj, Green.AgileMapper.Test.ContactWay domainObj) 
        { 
            if (fromObj == null) 
            { 
                return; 
            } 
            if (domainObj == null) 
            { 
                domainObj = new Green.AgileMapper.Test.ContactWay(); 
            } 
            domainObj.Phone = fromObj.Phone; 
            domainObj.Email = fromObj.Email; 
            domainObj.QQ = fromObj.QQ;

        }

        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto collection Warp fromObj Green.AgileMapper.Test.ContactWay collection; 
        /// </summary> 
        /// <param name="form">Green.AgileMapper.Test.ContactWayDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay collection</param>        
        public static List<Green.AgileMapper.Test.ContactWayDto> Warp(this IList<Green.AgileMapper.Test.ContactWay> domainObj) 
        { 
            List<Green.AgileMapper.Test.ContactWayDto> froms = new List<Green.AgileMapper.Test.ContactWayDto>(); 
            domainObj.ToList().ForEach(t =&gt; 
            { 
                froms.Add(Warp(t)); 
            }); 
            return froms; 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto collection Warp domainObj Green.AgileMapper.Test.ContactWay collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.ContactWayDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay collection</param>      
        public static void Warp(this IList<Green.AgileMapper.Test.ContactWayDto> fromObj, IList<Green.AgileMapper.Test.ContactWay> domainObj) 
        { 
            fromObj.Warp(domainObj, (fromObjItem, domainObjItem) =&gt; fromObjItem.Equals(domainObjItem), false); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto collection Warp domainObj Green.AgileMapper.Test.ContactWay collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.ContactWayDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay collection</param> 
        /// <param name="isDeleteNotInFromItem">Delete the item that not in From collection</param>           
        public static void Warp(this IList<Green.AgileMapper.Test.ContactWayDto> fromObj, IList<Green.AgileMapper.Test.ContactWay> domainObj, bool isDeleteNotInFromItem) 
        { 
            fromObj.Warp(domainObj, (fromObjItem, domainObjItem) =&gt; fromObjItem.Equals(domainObjItem), isDeleteNotInFromItem); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto collection Warp domainObj Green.AgileMapper.Test.ContactWay collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.ContactWayDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay collection</param> 
        /// <param name="equalPredicate">the from item equal to item expression</param>           
        public static void Warp(this IList<Green.AgileMapper.Test.ContactWayDto> fromObj, IList<Green.AgileMapper.Test.ContactWay> domainObj, Func<Green.AgileMapper.Test.ContactWayDto, Green.AgileMapper.Test.ContactWay, bool> equalPredicate) 
        { 
            fromObj.Warp(domainObj, equalPredicate, false); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.ContactWayDto collection Warp domainObj Green.AgileMapper.Test.ContactWay collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.ContactWayDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.ContactWay collection</param> 
        /// <param name="equalPredicate">the from item equal to item expression</param>      
        /// <param name="isDeleteNotInFromItem">Delete the item that not in From collection</param>     
        public static void Warp(this IList<Green.AgileMapper.Test.ContactWayDto> fromObj, IList<Green.AgileMapper.Test.ContactWay> domainObj, Func<Green.AgileMapper.Test.ContactWayDto, Green.AgileMapper.Test.ContactWay, bool> equalPredicate, bool isDeleteNotInFromItem) 
        { 
            if (fromObj == null) 
            { 
                return; 
            }

            if (domainObj == null) 
            { 
                domainObj = new List<Green.AgileMapper.Test.ContactWay>(); 
            }

            fromObj.ToList().ForEach(fromObjItem =&gt; 
            { 
                Green.AgileMapper.Test.ContactWay toItem = default(Green.AgileMapper.Test.ContactWay); 
                if (equalPredicate != null) 
                { 
                    toItem = domainObj.SingleOrDefault(domainObjItem =&gt; equalPredicate(fromObjItem, domainObjItem)); 
                } 
                if (toItem == null) 
                { 
                    toItem = new Green.AgileMapper.Test.ContactWay(); 
                    domainObj.Add(toItem); 
                } 
                Warp(fromObjItem, toItem); 
            });

            if (isDeleteNotInFromItem) 
            { 
                domainObj.Where(domainObjItem =&gt; fromObj.FirstOrDefault(fromObjItem =&gt; equalPredicate(fromObjItem, domainObjItem)) == null) 
                    .ToList().ForEach(t =&gt; 
                    { 
                        domainObj.Remove(t); 
                    }); 
            } 
        } 
    } 
}

 

3.cs:

using System; 
using System.Linq; 
using System.Data; 
using System.Collections.Generic;

namespace Green.AgileMapper 
{ 
    public static partial class AgileMapperMapping 
    { 
        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto  Warp fromObj Green.AgileMapper.Test.KeyValuePair; 
        /// </summary> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair</param> 
        /// <returns>Green.AgileMapper.Test.KeyValuePairDto</returns> 
        public static Green.AgileMapper.Test.KeyValuePairDto Warp(this Green.AgileMapper.Test.KeyValuePair domainObj) 
        { 
            var fromObj = new Green.AgileMapper.Test.KeyValuePairDto(); 
            fromObj.Key = domainObj.Key; 
            fromObj.Value = domainObj.Value; 
            return fromObj; 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto  Warp domainObj Green.AgileMapper.Test.KeyValuePair; 
        /// </summary> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair</param> 
        /// <returns>fromObj</returns> 
        public static void Warp(this Green.AgileMapper.Test.KeyValuePairDto fromObj, Green.AgileMapper.Test.KeyValuePair domainObj) 
        { 
            if (fromObj == null) 
            { 
                return; 
            } 
            if (domainObj == null) 
            { 
                domainObj = new Green.AgileMapper.Test.KeyValuePair(); 
            } 
            domainObj.Key = fromObj.Key; 
            domainObj.Value = fromObj.Value;

        }

        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto collection Warp fromObj Green.AgileMapper.Test.KeyValuePair collection; 
        /// </summary> 
        /// <param name="form">Green.AgileMapper.Test.KeyValuePairDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair collection</param>        
        public static List<Green.AgileMapper.Test.KeyValuePairDto> Warp(this IList<Green.AgileMapper.Test.KeyValuePair> domainObj) 
        { 
            List<Green.AgileMapper.Test.KeyValuePairDto> froms = new List<Green.AgileMapper.Test.KeyValuePairDto>(); 
            domainObj.ToList().ForEach(t =&gt; 
            { 
                froms.Add(Warp(t)); 
            }); 
            return froms; 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto collection Warp domainObj Green.AgileMapper.Test.KeyValuePair collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.KeyValuePairDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair collection</param>      
        public static void Warp(this IList<Green.AgileMapper.Test.KeyValuePairDto> fromObj, IList<Green.AgileMapper.Test.KeyValuePair> domainObj) 
        { 
            fromObj.Warp(domainObj, (fromObjItem, domainObjItem) =&gt; fromObjItem.Equals(domainObjItem), false); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto collection Warp domainObj Green.AgileMapper.Test.KeyValuePair collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.KeyValuePairDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair collection</param> 
        /// <param name="isDeleteNotInFromItem">Delete the item that not in From collection</param>           
        public static void Warp(this IList<Green.AgileMapper.Test.KeyValuePairDto> fromObj, IList<Green.AgileMapper.Test.KeyValuePair> domainObj, bool isDeleteNotInFromItem) 
        { 
            fromObj.Warp(domainObj, (fromObjItem, domainObjItem) =&gt; fromObjItem.Equals(domainObjItem), isDeleteNotInFromItem); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto collection Warp domainObj Green.AgileMapper.Test.KeyValuePair collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.KeyValuePairDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair collection</param> 
        /// <param name="equalPredicate">the from item equal to item expression</param>           
        public static void Warp(this IList<Green.AgileMapper.Test.KeyValuePairDto> fromObj, IList<Green.AgileMapper.Test.KeyValuePair> domainObj, Func<Green.AgileMapper.Test.KeyValuePairDto, Green.AgileMapper.Test.KeyValuePair, bool> equalPredicate) 
        { 
            fromObj.Warp(domainObj, equalPredicate, false); 
        }

        /// <summary> 
        /// Green.AgileMapper.Test.KeyValuePairDto collection Warp domainObj Green.AgileMapper.Test.KeyValuePair collection; 
        /// </summary> 
        /// <param name="fromObj">Green.AgileMapper.Test.KeyValuePairDto collection</param> 
        /// <param name="domainObj">Green.AgileMapper.Test.KeyValuePair collection</param> 
        /// <param name="equalPredicate">the from item equal to item expression</param>      
        /// <param name="isDeleteNotInFromItem">Delete the item that not in From collection</param>     
        public static void Warp(this IList<Green.AgileMapper.Test.KeyValuePairDto> fromObj, IList<Green.AgileMapper.Test.KeyValuePair> domainObj, Func<Green.AgileMapper.Test.KeyValuePairDto, Green.AgileMapper.Test.KeyValuePair, bool> equalPredicate, bool isDeleteNotInFromItem) 
        { 
            if (fromObj == null) 
            { 
                return; 
            }

            if (domainObj == null) 
            { 
                domainObj = new List<Green.AgileMapper.Test.KeyValuePair>(); 
            }

            fromObj.ToList().ForEach(fromObjItem =&gt; 
            { 
                Green.AgileMapper.Test.KeyValuePair toItem = default(Green.AgileMapper.Test.KeyValuePair); 
                if (equalPredicate != null) 
                { 
                    toItem = domainObj.SingleOrDefault(domainObjItem =&gt; equalPredicate(fromObjItem, domainObjItem)); 
                } 
                if (toItem == null) 
                { 
                    toItem = new Green.AgileMapper.Test.KeyValuePair(); 
                    domainObj.Add(toItem); 
                } 
                Warp(fromObjItem, toItem); 
            });

            if (isDeleteNotInFromItem) 
            { 
                domainObj.Where(domainObjItem =&gt; fromObj.FirstOrDefault(fromObjItem =&gt; equalPredicate(fromObjItem, domainObjItem)) == null) 
                    .ToList().ForEach(t =&gt; 
                    { 
                        domainObj.Remove(t); 
                    }); 
            } 
        } 
    } 
}

  在这里的代码生产后很乱并未格式化处理，需要我们在VS中自动Ctrl+K+D格式，如果你希望生成时候就帮助格式化了的话，你可以参见工具CoolFormat源代码格式化，安装工具利用CMD命令批量格式化（可以参见百度百科：http://baike.baidu.com/view/4367725.htm）。在项目暂不会考虑这块，如果你有兴趣的可以先帮助完成，谢谢。

具体请参见项目，存在任何问题或者bug可以随时给我留言，谢谢。




 本文转自 破狼 51CTO博客，原文链接：http://blog.51cto.com/whitewolfblog/822652，如需转载请自行联系原作者


文章标签：
C++
C#
开发工具
IDE
存储
技术小胖子
目录
相关文章
愿天堂没有BUG（公众号同名）
|
6月前
|
设计模式 开发框架 前端开发
项目开发中，真的有必要定义VO，BO，PO，DO，DTO这些吗？
存在即是合理的，业务复杂，人员协同性要求高的场景下，这些规范性的东西不按着来虽然不会出错，程序照样跑，但是遵守规范会让程序更具扩展性和可读性，都是前辈血淋淋的宝贵经验，为什么不用？
愿天堂没有BUG（公众号同名）
349 0
马超伟
|
存储 前端开发 Java
一文理解什么是DTO、VO、BO、PO、DO，并推荐一款IDEA转换插件
一文理解什么是DTO、VO、BO、PO、DO，并推荐一款IDEA转换插件
马超伟
507 0
一文理解什么是DTO、VO、BO、PO、DO，并推荐一款IDEA转换插件
No8g攻城狮
|
7月前
|
Java Maven
【Java用法】使用EasyPoi导入与导出Excel文档的解决方案
【Java用法】使用EasyPoi导入与导出Excel文档的解决方案
No8g攻城狮
155 0
T-OPEN
|
5月前
|
Java Maven
jxls和easypoi实现 java 实现动态组装列头导出（动态head）
jxls和easypoi实现 java 实现动态组装列头导出（动态head）
T-OPEN
96 0
GIS技术杂谈
|
JSON 定位技术 API
Cesium开发：单个对象Entity
Cesium开发：单个对象Entity
GIS技术杂谈
130 0
莫逸风
|
SQL 前端开发 Java
Swagger直接返回MybatisPlus的Page类文档不展开显示问题剖析
Swagger直接返回MybatisPlus的Page类文档不展开显示问题剖析
莫逸风
450 0
Swagger直接返回MybatisPlus的Page类文档不展开显示问题剖析
-编程工程师-
|
JSON 数据格式
SAP UI5 视图如何使用工程里的 sample data 作为 JSON model 的数据源
SAP UI5 视图如何使用工程里的 sample data 作为 JSON model 的数据源
-编程工程师-
119 0
SAP UI5 视图如何使用工程里的 sample data 作为 JSON model 的数据源
-编程工程师-
如何启用SAP C4C自定义BO的Text Collection功能
如何启用SAP C4C自定义BO的Text Collection功能
-编程工程师-
113 0
如何启用SAP C4C自定义BO的Text Collection功能
开发工程师
一种不通过UI给C4C自定义BO创建测试数据的方式
一种不通过UI给C4C自定义BO创建测试数据的方式
开发工程师
86 0
一种不通过UI给C4C自定义BO创建测试数据的方式
祖师爷
flowable 部署流程定义(从Classpath) 和 (根据ui.modeler的 modelId部署)
flowable 部署流程定义(从Classpath) 和 (根据ui.modeler的 modelId部署)
祖师爷
158 0

热门文章

最新文章

  • 1
    企业应用架构实践（复杂性应对之道）
  • 2
    SolidWorks2021中文版【Solid Works 附补丁】完美破解版下载 安装教程
  • 3
    3+1保障：高可用系统稳定性是如何炼成的？
  • 4
    大数据上手实战！《Elasticsearch 实战进阶营》第二季限时免费报名啦
  • 5
    OLAP与OLTP介绍
  • 6
    浅显易懂的机器学习（八）—— 随机森林分类
  • 7
    Windows 2008 AD 备份
  • 8
    《Ext JS权威指南》——2.9节为本书示例准备一个模板
  • 9
    NS2原理
  • 10
    Asp.net MVC2.0系列文章-显示列表和详细页面操作
  • 1
    Java中数组详解
    38
  • 2
    智能评估时代：SurveyKing开源问卷系统YYDS
    61
  • 3
    LabVIEW编程LabVIEW开发高级数据采集技术 操作数字IO 例程与相关资料
    37
  • 4
    【大模型】描述与 LLM 相关的个人项目或感兴趣的领域
    37
  • 5
    【大模型】使用哪些资源来了解 LLM 的最新进展？
    47
  • 6
    LabVIEW编程LabVIEW开发高级数据采集技术 计数器定时器的操作 例程与相关资料
    24
  • 7
    LabVIEW编程LabVIEW开发高级数据采集技术 模拟波形的生成 例程与相关资料
    22
  • 8
    Linux：进程等待 & 进程替换
    27
  • 9
    LabVIEW编程LabVIEW开发高级数据采集技术 同步 例程与相关资料
    19
  • 10
    LabVIEW编程LabVIEW开发高级数据采集技术定时与触发 例程与相关资料
    17

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）