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

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

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

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

下面看看任然是上个测试类模型的代码生成（在这里测试DO，DTO类进行了重构为了更全面的测试，具体请看CodePlexhttp://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) => 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) => 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 =>
            {
                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) => 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) => 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>();
            }

            //如果需要删除不存在于 from的list集合,先删除后修改
            if (isDeleteNotInFromItem)
            {
                domainObj.Where(domainObjItem => fromObj.FirstOrDefault(fromObjItem => equalPredicate(fromObjItem, domainObjItem)) == null)
                    .ToList().ForEach(t =>
                    {
                        domainObj.Remove(t);
                    });
            }

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

        }
    }
}

2.cs 

using System.Collections.Generic;
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 =>
            {
                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) => 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) => 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>();
            }

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

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

        }
    }
}

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 =>
            {
                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) => 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) => 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>();
            }

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

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

        }
    }
}

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

  具体请参见项目，存在任何问题或者bug可以随时给我留言，谢谢。项目地址CodePlex http://agilemapper.codeplex.com/

作者：破  狼 
出处：http://www.cnblogs.com/whitewolf/ 
本文版权归作者，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。该文章也同时发布在我的独立博客中-个人独立博客、博客园--破狼和51CTO--破狼。http://www.cnblogs.com/whitewolf/archive/2012/03/31/AgileMapper2.html

时间： 2024-09-23 08:02:39

Green.AgileMapper项目(2)-新增DO和DTO代码生成的相关文章

Green.AgileMapper新增-Green.ObjectPickUper(do到dto对象的默认抽取)

     Green.AgileMapper意在处理领域驱动开发中对象之间的Mapper(如果你还不了解Green.AgileMapper,从这里开始Green.AgileMapper开源项目的使用(1) 和Green.AgileMapper项目(2)-新增DO和DTO代码生成,项目地址:CodePlexhttp://agilemapper.codeplex.com/),本项目在后期会针对领域建模提供设计时候支持,利用EF和NHibernate作为底层ORM框架产生自己的领域框架,在设计时才会采

Green.AgileMapper开源项目的使用(1)

     在架构设计中,利用领域驱动开发时,涉及到do(领域对象)和dto(数据传输对象)的相互装换匹配,这段代码简单但是重复频率太多,写得我很冒火(我有个职责是wcf SOA包装),我是个不喜欢重复劳动的懒人,我在网上搜索等到很多实体匹配的框架EmitMapper,AutoMapper等,但是他们都不能满足dto和do的对象的按规则匹配包装.最后我只得花了半个小时写了一个简单的代码生成器,完成了我的任务.但是事后总觉得不爽,于是有了写下这个AgileMapper框架来适应领域开发中的po,do

中科院在粤合作项目去年新增利税20多亿

汪洋会见白春礼表示,推动科研成果尽快实现产业化 羊城 昨日下午,省委书记汪洋在广州会见了正在广东调研省院合作的中科院常务副院长白春礼一行. 自2009年1月广东省和中科院签署新一轮战略合作协议以来,双方大力推进全面战略合作,顺利完成了年度工作任务.据统计,中科院已有68个研究所在广东实施合作项目约450项,科技成果使广东企业去年新增销售收入约148亿元,新增利税20多亿元. 汪洋说,广东对省院合作取得的初步成效感到满意.事实证明,推进省院全面战略合作,加快了中科院的科技成果转化,有利于广东提高自

中石油两项目每月新增加工量80万吨

"现在整体供应还比较正常,每月大约能有70万吨的产能,主要是石油.柴油和一些化工原料."11月18日下午,广西石化分公司宣传部人士告诉<每日经济新闻>记者. 记者了解到,位于广西壮族自治区钦州市郊的广西石化1000万吨/年炼油项目已于今年9月8号建成投产,项目前后总投资151亿,是广西迄今为止单项投资最大的项目. 上述人士向记者透露,原定产能1000万吨,主要供应西南.华南地区."如果满负荷生产的话,每年可向西南地区供应830万吨汽油.柴油.航空煤油.液体石油气等

Git@OSC 项目演示新增接入百度 BAE 平台

Git@OSC 面世已经将近三年,致力于为国内的开发者提供一个快速可靠的代码托管服务:同时我们也在不断接入优秀的第三方服务提供商,来为用户提供方便好用的一键部署功能.目前已经有 CF 平台的MoPaaS (www.mopaas.com) 以及 Docker 平台的 灵雀云 (www.alauda.cn) 两个服务.而在今天,我们很高兴与百度达成战略合作,深度集成百度开放云应用引擎 BAE,让用户不仅能享受到 Git 的极速免费服务,而且可以享受到 BAE 平台快速可靠的部署服务,两者的集成更是方

Android项目从Eclipse增加支持Android Studio

使用Eclipse开发Android已经有些年头了,然而Android Studio(后面简称AS)为谷歌自己推的IDE.现在AS已经出了2.0版本,其功能的确要比Eclipse要多. AS对硬件要求较高,Eclipse使用ADT插件也是简单易用.本文不对这2个IDE的优缺点进行阐述,没有哪个一定能完全替代哪一个这么一说,选择自己喜欢的就好. 不过博主喜欢接触新事务,AS都出这么久了,也该拿出来遛遛了.对于一直使用Eclipse开发的安卓项目如何转换增加支持AS.(是增加支持AS,处理后AS和E

SharePoint项目中新建类库的错误处理及项目建设中的常见问题

第一次SP项目总监遇到各种问题,以下是总结: 问题1.创建SP项目的时候"场解决方案"跟"沙盒解决方案"是有区别的,具体可以看MSDN官方文档,这里简单摘抄如下: 1)场解决方案:承载与W3WP.exe中,其运行会影响整个场的代码,并可以附加W3WP.exe进程来调试(vs要以管理员身份运行). 2)沙盒解决方案:承载与SPUCWorkerProcess.exe中,so重启时IIS应用程序池和IIS服务器都不需要重启,不影响其他场的代码,并且沙盒的运行时受到监视的,

was新增servlet访问不到

问题描述 was新增servlet访问不到 项目生产环境通过F5集群ihs请求was应用,现在我在项目中新增一个servlet,在web.xml中进行了配置,然后整个项目打包发布到was上,项目其他功能及页面都正常,唯独新增的这个servlet访问不到,报HTTP404!!!测试环境没有F5,也是was服务器,发布后,正常访问,没有问题!求解^^ 解决方案 首先你本地调试通过了吗?其次was你重启过了吗? 解决方案二: 本地测试通过,WAS也重启过!

关于Debug不进行项目生成的问题

问题描述 Debug模式下,有一些修改过的项目,不进行编译是怎么回事??导致明明是正确的,因为没编译最新的类库导致错误.而Release就没有这个问题--我在Debug下清理方案重新生成,还是不行.这是哪里没设置好吗??==================================例如,我在项目A新增一个属性X在项目B引用了,在Debug下就提示属性X不存在而如果是Release就没有任何问题.我选择清理--然后重新生成,也是不行清空目标项目bindebug下的所有文件是好用的按理说修改后