分享原创可复用且非侵入性代码生成工具(for .net)

入行IT十年了,这是本人第一次网上’献丑‘。迫于工作压力，花了大半年时间写了这个生成器以辅助开发。如有价值请多多给予建议，谢谢

好了，废话少说，开动！

 QA.

1.为什么要用代码生成器？

　　当然是为了快速开发，且保证代码的一致性，便于维护。

2.代码生成器没缺点吗？

　　当然有缺点了，就是它不能代替人，如果鼠标一按就生成整个系统！那我们程序员是在一边喝咖啡还是背包走人？幸好代码生成器不会那么智能..

3.代码生成器生成的代码是一锤子买卖？

　　可以不是一锤子买卖，反复修改生成器的元数据，可以持久享受代码生成器的好处。

4.文中这个代码生成器有什么特点？

　　1）理论上如果熟悉这个代码生成器的原理，任何人可以定制出自己希望的常用模式代码（为什么叫模式，指个人或团队实现功能的代码编写模式/习惯性代码等等），

目前生成的代码是针对的.NET平台下的ASP.NET MVC3+ EF+WCF+Web代码。

　　2）非侵入性，代码可以完全定制以适应当前架构需要，而不是架构适应生成器。

　　3）难度系数比较高，需要掌握antlr 文法分析+基础的java控制台编程知识+winform.net.但回报可能会远远大于付出。

5.这个工具，有人在实际中用吗？

　　作者和所在开发团队在使用。效果非常好，大大的减少了开发成本和测试维护成本。

6.开源吗？

　　计划中，由于个人工作太忙，等有空闲时间进行重构整理，以免仓促而误人子弟。

0.概要介绍

设计阶段：在文本编辑器里面编辑xml模型和数据模型元数据，工具会自动校验和分析，并生成相应代码和sql。

持久阶段：1. 设计阶段生成表后，工具从数据库获取最新表/视图，可以生成相应的增删改查功能也页面等等。

　　　　   2. 支持自定义参数化查询（语法采用标准sql,支持单表/多表/高级查询），自数据层到服务层，web层的生成。

　　　　　3. 反向工程：支持数据库表到设计阶段的数据模型元数据的同步，使设计永不过时并复用。

　　　　   4. 支持生成数据词典。

生成器窗口：

 

红色区域可以望文生义，不用赘述。

双击错误列表可以打开相应文件并使光标定位到错误点。

1.设计阶段

　　包括对xml和数据库设计的设计。

　　

　　1.1 Xml的Dom代码生成

　　1.1.1 xml语法规则如下：

　　

1.1.2 生成dom操作代码：

1.1.3 生成的代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using CodeHelper.Xml.Extension;
using CodeHelper.Xml;

namespace CodeHelper.Workflow.Designer.Core.Config
{

    public class WorkflowDefine
    : DataNode
    {
        public WorkflowDefine
        ()
            : base()
        {
        }

        public WorkflowDefine
        (XmlNode dom)
            : base(dom)
        {
        }

        public WorkflowDefine
        (Document document)
            : base(document)
        {
        }

        public override string XML_TAG_NAME
        {
            get
            {
                return "WorkflowDefine";
            }
            set
            {
                throw new Exception("cannot set");
            }
        }

        public event ProperyChanged<string> OnId_ProperyChanged;
        public override string Id
        {
            get
            {
                if (this.Dom.Attributes["Id"] == null)
                    return default(string);
                return this.Dom.Attributes["Id"].Value.ToT<string>();
            }
            set
            {
                var attr = this.Dom.Attributes.OfType<XmlAttribute>()
                  .FirstOrDefault(x => x.Name == "Id");
                var oldValue = default(string);
                var newValue = value;
                if (attr == null)
                {
                    attr = this.Dom.Attributes.Append(this.Dom.OwnerDocument.CreateAttribute("Id"));
                }
                else
                {
                    oldValue = this.Dom.Attributes["Id"].Value.ToT<string>();
                }

                if (value != null)
                    attr.Value = value.ToString();

                if (OnId_ProperyChanged != null && oldValue != newValue)
                {
                    OnId_ProperyChanged(oldValue, newValue);
                }
                this.FireAnyProperyChanged("Id", oldValue, newValue);
            }
        }
        public event ProperyChanged<string> OnName_ProperyChanged;
        public string Name
        {
            get
            {
                if (this.Dom.Attributes["Name"] == null)
                    return default(string);
                return this.Dom.Attributes["Name"].Value.ToT<string>();
            }
            set
            {
                var attr = this.Dom.Attributes.OfType<XmlAttribute>()
                  .FirstOrDefault(x => x.Name == "Name");
                var oldValue = default(string);
                var newValue = value;
                if (attr == null)
                {
                    attr = this.Dom.Attributes.Append(this.Dom.OwnerDocument.CreateAttribute("Name"));
                }
                else
                {
                    oldValue = this.Dom.Attributes["Name"].Value.ToT<string>();
                }

                if (value != null)
                    attr.Value = value.ToString();

                if (OnName_ProperyChanged != null && oldValue != newValue)
                {
                    OnName_ProperyChanged(oldValue, newValue);
                }
                this.FireAnyProperyChanged("Name", oldValue, newValue);
            }
        }
        public event ProperyChanged<string> OnDescription_ProperyChanged;
        public string Description
        {
            get
            {
                if (this.Dom.Attributes["Description"] == null)
                    return default(string);
                return this.Dom.Attributes["Description"].Value.ToT<string>();
            }
            set
            {
                var attr = this.Dom.Attributes.OfType<XmlAttribute>()
                  .FirstOrDefault(x => x.Name == "Description");
                var oldValue = default(string);
                var newValue = value;
                if (attr == null)
                {
                    attr = this.Dom.Attributes.Append(this.Dom.OwnerDocument.CreateAttribute("Description"));
                }
                else
                {
                    oldValue = this.Dom.Attributes["Description"].Value.ToT<string>();
                }

                if (value != null)
                    attr.Value = value.ToString();

                if (OnDescription_ProperyChanged != null && oldValue != newValue)
                {
                    OnDescription_ProperyChanged(oldValue, newValue);
                }
                this.FireAnyProperyChanged("Description", oldValue, newValue);
            }
        }
        public event ProperyChanged<string> OnVariable_ProperyChanged;
        public string Variable
        {
            get
            {
                if (this.Dom.Attributes["Variable"] == null)
                    return default(string);
                return this.Dom.Attributes["Variable"].Value.ToT<string>();
            }
            set
            {
                var attr = this.Dom.Attributes.OfType<XmlAttribute>()
                  .FirstOrDefault(x => x.Name == "Variable");
                var oldValue = default(string);
                var newValue = value;
                if (attr == null)
                {
                    attr = this.Dom.Attributes.Append(this.Dom.OwnerDocument.CreateAttribute("Variable"));
                }
                else
                {
                    oldValue = this.Dom.Attributes["Variable"].Value.ToT<string>();
                }

                if (value != null)
                    attr.Value = value.ToString();

                if (OnVariable_ProperyChanged != null && oldValue != newValue)
                {
                    OnVariable_ProperyChanged(oldValue, newValue);
                }
                this.FireAnyProperyChanged("Variable", oldValue, newValue);
            }
        }

        public FieldDef CreateFieldDef()
        {
            return this.Dom.CreateNode<FieldDef>();
        }

        public NodeList<FieldDef> Fields
        {
            get
            {
                NodeList<FieldDef> fields = null;
                XmlNode fields_node = null;

                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "Fields")
                    {
                        fields_node = node;
                        fields = new NodeList<FieldDef>(node);
                        break;
                    }
                }

                if (fields_node != null)
                {
                    foreach (XmlNode node in fields_node.ChildNodes)
                    {
                        fields.AddChild(new FieldDef(node));
                    }
                }
                else
                {
                    fields = this.Dom.CreateNode<NodeList<FieldDef>>("Fields");

                    this.AddChild(fields);
                }
                return fields;
            }
            set
            {
                throw new Exception("cannot set");
            }
        }
        public ClassDef CreateClassDef()
        {
            return this.Dom.CreateNode<ClassDef>();
        }

        public NodeList<ClassDef> Classes
        {
            get
            {
                NodeList<ClassDef> classes = null;
                XmlNode classes_node = null;

                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "Classes")
                    {
                        classes_node = node;
                        classes = new NodeList<ClassDef>(node);
                        break;
                    }
                }

                if (classes_node != null)
                {
                    foreach (XmlNode node in classes_node.ChildNodes)
                    {
                        classes.AddChild(new ClassDef(node));
                    }
                }
                else
                {
                    classes = this.Dom.CreateNode<NodeList<ClassDef>>("Classes");

                    this.AddChild(classes);
                }
                return classes;
            }
            set
            {
                throw new Exception("cannot set");
            }
        }
        public InitDef CreateInitDef()
        {
            return this.Dom.CreateNode<InitDef>();
        }

        public InitDef Init
        {
            get
            {
                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "InitDef" &&
                        node.Attributes["variable"] != null &&
                        node.Attributes["variable"].Value == "Init")
                    {
                        return new InitDef(node);
                    }
                }
                return null;
            }
            set
            {
                if (this.Init != null)
                {
                    this.Init.RemoveSelf();
                }

                var attr = this.Dom.OwnerDocument.CreateAttribute("variable");
                attr.Value = "Init";
                value.Dom.Attributes.Append(attr);

                this.Dom.AppendChild(value.Dom);
            }
        }
        public StartStateDef CreateStartStateDef()
        {
            return this.Dom.CreateNode<StartStateDef>();
        }

        public StartStateDef StartState
        {
            get
            {
                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "StartStateDef" &&
                        node.Attributes["variable"] != null &&
                        node.Attributes["variable"].Value == "StartState")
                    {
                        return new StartStateDef(node);
                    }
                }
                return null;
            }
            set
            {
                if (this.StartState != null)
                {
                    this.StartState.RemoveSelf();
                }

                var attr = this.Dom.OwnerDocument.CreateAttribute("variable");
                attr.Value = "StartState";
                value.Dom.Attributes.Append(attr);

                this.Dom.AppendChild(value.Dom);
            }
        }
        public TerminateStateDef CreateTerminateStateDef()
        {
            return this.Dom.CreateNode<TerminateStateDef>();
        }

        public TerminateStateDef TerminateState
        {
            get
            {
                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "TerminateStateDef" &&
                        node.Attributes["variable"] != null &&
                        node.Attributes["variable"].Value == "TerminateState")
                    {
                        return new TerminateStateDef(node);
                    }
                }
                return null;
            }
            set
            {
                if (this.TerminateState != null)
                {
                    this.TerminateState.RemoveSelf();
                }

                var attr = this.Dom.OwnerDocument.CreateAttribute("variable");
                attr.Value = "TerminateState";
                value.Dom.Attributes.Append(attr);

                this.Dom.AppendChild(value.Dom);
            }
        }
        public StateDef CreateStateDef()
        {
            return this.Dom.CreateNode<StateDef>();
        }

        public NodeList<StateDef> States
        {
            get
            {
                NodeList<StateDef> states = null;
                XmlNode states_node = null;

                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "States")
                    {
                        states_node = node;
                        states = new NodeList<StateDef>(node);
                        break;
                    }
                }

                if (states_node != null)
                {
                    foreach (XmlNode node in states_node.ChildNodes)
                    {
                        states.AddChild(new StateDef(node));
                    }
                }
                else
                {
                    states = this.Dom.CreateNode<NodeList<StateDef>>("States");

                    this.AddChild(states);
                }
                return states;
            }
            set
            {
                throw new Exception("cannot set");
            }
        }
        public ParallelDef CreateParallelDef()
        {
            return this.Dom.CreateNode<ParallelDef>();
        }

        public NodeList<ParallelDef> Parallels
        {
            get
            {
                NodeList<ParallelDef> parallels = null;
                XmlNode parallels_node = null;

                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "Parallels")
                    {
                        parallels_node = node;
                        parallels = new NodeList<ParallelDef>(node);
                        break;
                    }
                }

                if (parallels_node != null)
                {
                    foreach (XmlNode node in parallels_node.ChildNodes)
                    {
                        parallels.AddChild(new ParallelDef(node));
                    }
                }
                else
                {
                    parallels = this.Dom.CreateNode<NodeList<ParallelDef>>("Parallels");

                    this.AddChild(parallels);
                }
                return parallels;
            }
            set
            {
                throw new Exception("cannot set");
            }
        }
        public SubFlowStateDef CreateSubFlowStateDef()
        {
            return this.Dom.CreateNode<SubFlowStateDef>();
        }

        public NodeList<SubFlowStateDef> SubFlowStates
        {
            get
            {
                NodeList<SubFlowStateDef> subFlowStates = null;
                XmlNode subFlowStates_node = null;

                foreach (XmlNode node in this.Dom.ChildNodes)
                {
                    if (node.Name == "SubFlowStates")
                    {
                        subFlowStates_node = node;
                        subFlowStates = new NodeList<SubFlowStateDef>(node);
                        break;
                    }
                }

                if (subFlowStates_node != null)
                {
                    foreach (XmlNode node in subFlowStates_node.ChildNodes)
                    {
                        subFlowStates.AddChild(new SubFlowStateDef(node));
                    }
                }
                else
                {
                    subFlowStates = this.Dom.CreateNode<NodeList<SubFlowStateDef>>("SubFlowStates");

                    this.AddChild(subFlowStates);
                }
                return subFlowStates;
            }
            set
            {
                throw new Exception("cannot set");
            }
        }
    }

    public class StartStateDef
    : DataNode
    {
        public StartStateDef
        ()
            : base()
        {
        }

        public StartStateDef
        (XmlNode dom)
            : base(dom)
        {
        }

        public StartStateDef
        (Document document)
            : base(document)
        {
        }

        public override string XML_TAG_NAME
        {
            get
            {
                return "StartStateDef";
            }
            set
            {
                throw new Exception("cannot set");
            }
        }

        public event ProperyChanged<string> OnId_ProperyChanged;
        public override string Id
        {
            get
            {
                if (this.Dom.Attributes["Id"] == null)
                    return default(string);
                return this.Dom.Attributes["Id"].Value.ToT<string>();
            }
            set
            {
                var attr = this.Dom.Attributes.OfType<XmlAttribute>()
                  .FirstOrDefault(x => x.Name == "Id");
                var oldValue = default(string);
                var newValue = value;
                if (attr == null)
                {
                    attr = this.Dom.Attributes.Append(this.Dom.OwnerDocument.CreateAttribute("Id"));
                }
                else
                {
                    oldValue = this.Dom.Attributes["Id"].Value.ToT<string>();
                }

                if (value != null)
                    attr.Value = value.ToString();

                if (OnId_ProperyChanged != null && oldValue != newValue)
                {
                    OnId_ProperyChanged(oldValue, newValue);
                }
                this.FireAnyProperyChanged("Id", oldValue, newValue);
            }
        }
        public event ProperyChanged<string> OnName_ProperyChanged;
        public string Name
        {
            get
            {
                if (this.Dom.Attributes["Name"] == null)
                    return default(string);
                return this.Dom.Attributes["Name"].Value.ToT<string>();
            }
            set
            {
                var attr = this.Dom.Attributes.OfType<XmlAttribute>()
                  .FirstOrDefault(x => x.Name == "Name");
                var oldValue = default(string);
                var newValue = value;
                if (attr == null)
                {
                    attr = this.Dom.Attributes.Append(this.Dom.OwnerDocument.CreateAttribute("Name"));
                }
                else
                {
                    oldValue = this.Dom.Attributes["Name"].Value.ToT<string>();
                }

                if (value != null)
                    attr.Value = value.ToString();

                if (OnName_ProperyChanged != null && oldValue != newValue)
                {
                    OnName_ProperyChanged(oldValue, newValue);
                }
                this.FireAnyProperyChanged("Name", oldValue, newValue);
            }
        }

    }

    //此处省略3000行...
}

1.2 数据表及关系设计

1.2.1 数据语法如下：

1.2.2 生成数据库sql

1.2.3 生成的sql

IF OBJECT_ID(N'People',N'U') IS NOT NULL
DROP TABLE [dbo].[People];
CREATE TABLE [dbo].[People](
[Id] int NOT NULL,
[Name] nvarchar(200) ,
[UserId] int ,
[SchoolId] int ,
[Status] int ,
 CONSTRAINT [PK_People] PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF
    , ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

GO

1.3 持久化阶段

1.3.1 新建连接串

1.3.2 刷新链接,获取数据库所有的表和视图信息

刷新结果：

1.3.3 弹出生成操作

1.3.4 实体层生成

1.3.4.1 生成的EF实体类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain.Entities;
using Domain.AggregateRoot;

namespace AAA
{

    public class People : Entity, IAggregateRoot
    {
        public People()
        {
        }
        public People(System.Int32 id)
            : base(id)
        {
        }
        /// <summary>
        ///
        /// </summary>
        public DateTime? CreateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public String Name
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? SchoolId
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? Status
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public DateTime? UpdateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? UserId
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public virtual User User
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public virtual School School
        { get; set; }

        public void AssignFrom(People other)
        {
            this.CreateTime = other.CreateTime;
            this.Name = other.Name;
            this.SchoolId = other.SchoolId;
            this.Status = other.Status;
            this.UpdateTime = other.UpdateTime;
            this.UserId = other.UserId;
        }
    }
}

1.3.4.2 生成的EF映射类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain.Repository;

namespace AAA
{

    public interface IPeopleRepository : IRepository<People>, IDisposable
    {
        List<People> GetList(List<Guid> id_list);
    }
}

弹出生成Repository操作：

1.3.4.3 Repository接口代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain.Repository;

namespace AAA
{

    public interface IPeopleRepository : IRepository<People>, IDisposable
    {
        List<People> GetList(List<Guid> id_list);
    }
}

1.3.4.4 Specification规约代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Domain.Specification;

namespace AAA
{

    public static class PeopleSpecification
    {
        public static ISpecification<People> GetList(List<Guid> id_list)
        {
            return new DirectSpecification<People>(x => id_list.Contains(x.Id));
        }
    }
}

1.3.4.5 Repository实现代码：

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

namespace AAA
{

    public class PeopleRepository : Repository<People>, IPeopleRepository
    {
        public PeopleRepository(IQueryableUnitOfWork unitOfWork)
            : base(unitOfWork)
        {
        }

        public List<People> GetList(List<Guid> id_list)
        {
            return this.GetAll(PeopleSpecification.GetList(id_list)).ToList();
        }

        public void Dispose()
        {
            //throw new NotImplementedException();
        }
    }
}

1.3.5 Service层生成

1.3.5.1 弹出生成WCF操作：

1.3.5.2 生成DTO代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;

namespace AAA
{

    [DataContract]
    public class PeopleDto
    {
        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public DateTime? CreateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public Int32 Id
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public String Name
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public Int32? SchoolId
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public Int32? Status
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public DateTime? UpdateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        [DataMember]
        public Int32? UserId
        { get; set; }

    }
}

1.3.5.3 生成实体转DTO代码：（建议用automap替代）

 public static PeopleDto ConvertToPeopleDto(People entity)
 {
    return new PeopleDto{
      Id = entity.Id,
      Name = entity.Name,
      SchoolId = entity.SchoolId,
      Status = entity.Status,
      UserId = entity.UserId,
    };
 }

1.3.5.4 生成DTO转实体代码：（建议用automap替代）

 public static People ConvertToPeople(PeopleDto entityDto)
 {
    return new People(entityDto.Id){
      Name = entityDto.Name,
      SchoolId = entityDto.SchoolId,
      Status = entityDto.Status,
      UserId = entityDto.UserId,
    };
 }

1.3.5.5 生成基本Servie代码：（基础增删改查）

        #region App Service Interface

        ReturnInfoDto AddPeople(PeopleDto peopleDto);

        ReturnInfoDto UpdatePeople(PeopleDto peopleDto);

        ReturnInfoDto<PeopleDto> GetPeople(Guid id);

        ReturnInfoDto<List<PeopleDto>> GetPeopleList(List<Guid> id_list);

        ReturnInfoDto DeletePeople(Guid id);

        ReturnInfoDto DeletePeople(List<Guid> id_list);

        #endregion

        #region App Service Implement

        public ReturnInfoDto AddPeople(PeopleDto peopleDto)
        {
            var rtnInfo = new ReturnInfoDto();
            rtnInfo.Message = string.Empty;
            rtnInfo.IsSuccess = false;
            try
            {
                using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
                {
                    var peopleDB = new PeopleRepository(unitOfWork);
                    var people = DataConverter.ConvertToPeople(peopleDto);
                    peopleDB.Add(people);
                    unitOfWork.Commit();
                }
            }
            catch (Exception ex)
            {
                rtnInfo.Message = ex.Message;
                return rtnInfo;
            }

            rtnInfo.IsSuccess = true;
            return rtnInfo;
        }

        public ReturnInfoDto UpdatePeople(PeopleDto peopleDto)
        {
            var rtnInfo = new ReturnInfoDto();
            rtnInfo.Message = string.Empty;
            rtnInfo.IsSuccess = false;
            try
            {
                using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
                {
                    var peopleDB = new PeopleRepository(unitOfWork);
                    var info = peopleDB.Get(peopleDto.Id);
                    if (info == null)
                    {
                        rtnInfo.Message = "the data is not in system.";
                        return rtnInfo;
                    }
                    var other = DataConverter.ConvertToPeople(peopleDto);
                    info.AssignFrom(other);
                    peopleDB.Modify(info);
                    unitOfWork.Commit();
                }
            }
            catch (Exception ex)
            {
                rtnInfo.Message = ex.Message;
                return rtnInfo;
            }

            rtnInfo.IsSuccess = true;
            return rtnInfo;
        }

        public ReturnInfoDto<PeopleDto> GetPeople(Guid id)
        {
            var rtnInfo = new ReturnInfoDto<PeopleDto>();
            rtnInfo.Message = string.Empty;
            rtnInfo.IsSuccess = false;
            try
            {
                using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
                {
                    var peopleDB = new PeopleRepository(unitOfWork);
                    var people = peopleDB.Get(id);
                    if(people != null)
                    {
                        rtnInfo.Data = DataConverter.ConvertToPeopleDto(people);
                    }
                }
            }
            catch (Exception ex)
            {
                rtnInfo.Message = ex.Message;
                return rtnInfo;
            }

            rtnInfo.IsSuccess = true;
            return rtnInfo;
        }

        public ReturnInfoDto<List<PeopleDto>> GetPeopleList(List<Guid> id_list)
        {
            var rtnInfo = new ReturnInfoDto<List<PeopleDto>>();
            rtnInfo.Message = string.Empty;
            rtnInfo.IsSuccess = false;
            rtnInfo.Data = new List<PeopleDto>();
            try
            {
                using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
                {
                    var peopleDB = new PeopleRepository(unitOfWork);
                    var list = peopleDB.GetList(id_list);
                    if(list != null && list.Count > 0 )
                    {
                        list.ForEach( x => rtnInfo.Data.Add(DataConverter.ConvertToPeopleDto(x)));
                    }
                }
            }
            catch (Exception ex)
            {
                rtnInfo.Message = ex.Message;
                return rtnInfo;
            }

            rtnInfo.IsSuccess = true;
            return rtnInfo;
        }

        public ReturnInfoDto DeletePeople(Guid id)
        {
            var rtnInfo = new ReturnInfoDto();
            rtnInfo.Message = string.Empty;
            rtnInfo.IsSuccess = false;
            try
            {
                using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
                {
                    var peopleDB = new PeopleRepository(unitOfWork);
                    var people = peopleDB.Get(id);
                    if(people == null )
                    {
                        rtnInfo.Message = "the data is not in system.";
                        return rtnInfo;
                    }
                    //people.Available = false;
                    //peopleDB.Modify(people);
                    peopleDB.Remove(people);
                    unitOfWork.Commit();
                }
            }
            catch (Exception ex)
            {
                rtnInfo.Message = ex.Message;
                return rtnInfo;
            }

            rtnInfo.IsSuccess = true;
            return rtnInfo;
        }

        public ReturnInfoDto DeletePeople(List<Guid> id_list)
        {
            var rtnInfo = new ReturnInfoDto();
            rtnInfo.Message = string.Empty;
            rtnInfo.IsSuccess = false;
            try
            {
                using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
                {
                    var peopleDB = new PeopleRepository(unitOfWork);
                    var people_list = peopleDB.GetList(id_list);
                    foreach (var people in people_list)
                    {
                        //people.Available = false;
                        //peopleDB.Modify(people);
                        peopleDB.Remove(people);
                    }
                    unitOfWork.Commit();
                }
            }
            catch (Exception ex)
            {
                rtnInfo.Message = ex.Message;
                return rtnInfo;
            }

            rtnInfo.IsSuccess = true;
            return rtnInfo;
        }

        #endregion

        #region Distribute Service Interface

        [OperationContract]
        [WithoutAuthorization]
        [FaultContractAttribute(typeof(UnAuthorization))]
        ReturnInfoDto AddPeople(PeopleDto peopleDto);

        [OperationContract]
        [WithoutAuthorization]
        [FaultContractAttribute(typeof(UnAuthorization))]
        ReturnInfoDto UpdatePeople(PeopleDto peopleDto);

        [OperationContract]
        [WithoutAuthorization]
        [FaultContractAttribute(typeof(UnAuthorization))]
        ReturnInfoDto<PeopleDto> GetPeople(Guid id);

        [OperationContract]
        [WithoutAuthorization]
        [FaultContractAttribute(typeof(UnAuthorization))]
        ReturnInfoDto<List<PeopleDto>> GetPeopleList(List<Guid> id_list);

        [OperationContract]
        [WithoutAuthorization]
        [FaultContractAttribute(typeof(UnAuthorization))]
        ReturnInfoDto DeletePeople(Guid id);

        [OperationContract]
        [WithoutAuthorization]
        [FaultContractAttribute(typeof(UnAuthorization))]
        ReturnInfoDto DeletePeopleList(List<Guid> id_list);

        #endregion

        #region Distribute Service Implement

        public ReturnInfoDto AddPeople(PeopleDto peopleDto)
        {
            return _appService.AddPeople(peopleDto);
        }

        public ReturnInfoDto UpdatePeople(PeopleDto peopleDto)
        {
            return _appService.UpdatePeople(peopleDto);
        }

        public ReturnInfoDto<PeopleDto> GetPeople(Guid id)
        {
            return _appService.GetPeople( id );
        }

        public ReturnInfoDto<List<PeopleDto>> GetPeopleList(List<Guid> id_list)
        {
            return _appService.GetPeopleList( id_list );
        }

        public ReturnInfoDto DeletePeople(Guid id)
        {
            return _appService.DeletePeople( id );
        }

        public ReturnInfoDto DeletePeopleList(List<Guid> id_list)
        {
            return _appService.DeletePeople( id_list );
        }

        #endregion

        #region Service Layer

        public ReturnInfo AddPeople(PeopleInfo peopleInfo)
        {
            var result = new ReturnInfo();

            try
            {
                var dto = DataConverter.ConvertToPeopleDto(peopleInfo);
                var rslt = serviceClient.Invoke<ReturnInfoDto>(x => x.AddPeople(dto));
                result.IsSuccess = rslt.IsSuccess;
                result.Message = rslt.Message;
                
            }
            catch (Exception e)
            {
                LogHelper.Error(e);
                result.IsSuccess = false;
                result.Message = "call service error";
            }

            return result;
        }

        public ReturnInfo UpdatePeople(PeopleInfo peopleInfo)
        {
            var result = new ReturnInfo();

            try
            {
                var dto = DataConverter.ConvertToPeopleDto(peopleInfo);
                var rslt = serviceClient.Invoke<ReturnInfoDto>(x => x.UpdatePeople(dto));
                result.IsSuccess = rslt.IsSuccess;
                result.Message = rslt.Message;
                
            }
            catch (Exception e)
            {
                LogHelper.Error(e);
                result.IsSuccess = false;
                result.Message = "call service error";
            }

            return result;
        }

        public ReturnInfo<PeopleInfo> GetPeople(Guid id)
        {
            var result = new ReturnInfo<PeopleInfo>();

            try
            {
                var rslt = serviceClient.Invoke<ReturnInfoDto<PeopleDto>>(x => x.GetPeople(id));
                result.Data = DataConverter.ConvertToPeopleInfo(rslt.Data);
                result.IsSuccess = rslt.IsSuccess;
                result.Message = rslt.Message;
                
            }
            catch (Exception e)
            {
                LogHelper.Error(e);
                result.IsSuccess = false;
                result.Message = "call service error";
            }

            return result;
        }

        public ReturnInfo<List<PeopleInfo>> GetPeopleList(List<Guid> id_list)
        {
            var result = new ReturnInfo<List<PeopleInfo>>();
            result.Data = new List<PeopleInfo>();

            try
            {
                var rslt = serviceClient.Invoke<ReturnInfoDto<List<PeopleDto>>>(x => x.GetPeopleList(id_list));
                result.IsSuccess = rslt.IsSuccess;
                result.Message = rslt.Message;
                if (rslt.IsSuccess )
                {
                    if (rslt.Data != null && rslt.Data.Count > 0)
                    {
                        rslt.Data.ForEach(x => result.Data.Add(DataConverter.ConvertToPeopleInfo(x)));
                    }
                }
            }
            catch (Exception e)
            {
                LogHelper.Error(e);
                result.IsSuccess = false;
                result.Message = "call service error";
            }

            return result;
        }

        public ReturnInfo DeletePeople(Guid id)
        {
            var result = new ReturnInfo();

            try
            {
                var rslt = serviceClient.Invoke<ReturnInfoDto>(x => x.DeletePeople(id));
                result.IsSuccess = rslt.IsSuccess;
                result.Message = rslt.Message;
                
            }
            catch (Exception e)
            {
                LogHelper.Error(e);
                result.IsSuccess = false;
                result.Message = "call service error";
            }

            return result;
        }

        public ReturnInfo DeletePeople(List<Guid> id_list)
        {
            var result = new ReturnInfo();

            try
            {
                var rslt = serviceClient.Invoke<ReturnInfoDto>(x => x.DeletePeopleList(id_list));
                result.IsSuccess = rslt.IsSuccess;
                result.Message = rslt.Message;
                
            }
            catch (Exception e)
            {
                LogHelper.Error(e);
                result.IsSuccess = false;
                result.Message = "call service error";
            }

            return result;
        }

        #endregion

1.3.5.6 生成CCFlowService：此处省略（比较私有）

1.3.6 Web层生成

1.3.6.1 弹出ViewMode生成操作：

1.3.6.2 生成ViewModel代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;

namespace AAA
{

    public class PeopleInfo
    {
        /// <summary>
        ///
        /// </summary>
        public DateTime? CreateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32 Id
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public String Name
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? SchoolId
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? Status
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public DateTime? UpdateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? UserId
        { get; set; }

    }
}

1.3.6.3 生成ViewModel转WCF DTO代码：（建议用automapper替代）

 public static PeopleDto ConvertToPeopleDto(PeopleInfo info)
 {
    return new PeopleDto{
      Id = info.Id,
      Name = info.Name,
      SchoolId = info.SchoolId,
      Status = info.Status,
      UserId = info.UserId,
    };
 }

1.3.6.4 生成WCF DTO转ViewModel代码：（建议用automapper替代）

 public static PeopleInfo ConvertToPeopleInfo(PeopleDto dto )
 {
    return new PeopleInfo(){
      Id = dto.Id,
      Name = dto.Name,
      SchoolId = dto.SchoolId,
      Status = dto.Status,
      UserId = dto.UserId,
    };
 }

1.3.6.5 弹出生成View操作：

1.3.6.6 生成编辑页面Model代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
namespace AAA
{

    public class PeopleInfo
    {
        /// <summary>
        ///
        /// </summary>
        public DateTime? CreateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32 Id
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public String Name
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? SchoolId
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? Status
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public DateTime? UpdateTime
        { get; set; }

        /// <summary>
        ///
        /// </summary>
        public Int32? UserId
        { get; set; }

    }
}

1.3.6.7 生成编辑页面代码：

@model EditPeopleModel
@{
    Layout = "~/Views/Shared/_SimpleLayout.cshtml";

    if(this.Model.Id.HasValue){
        ViewBag.Title = "Edit Item";
    }
    else{
        ViewBag.Title = "Add Item";
    }
}

@section js{
<script src="../../Scripts/jquery.validate.js" type="text/javascript"></script>
<script language = "javascript" type="text/javascript">
        function OnClose(refresh) {
            if (parent.MsgBox != undefined) {

                if (refresh) {
                    if (parent.MsgBox.Callback != null) {
                        parent.MsgBox.Callback();
                        parent.MsgBox.Callback = null;
                    }
                }
                parent.MsgBox.Callback = null;

                parent.MsgBox.Close();

            }
            else {
                window.close();
            }
        }
        
        $(function () {

            if (parent.MsgBox != undefined) {
                parent.MsgBox.CancelCallback = true;
            }

            $('#btnSaveAndClose').click(function () {

                $('#IsSave').val(true);

                $('#editForm').submit();

            });

            $('#btnCancel').click(function () {

                OnClose();

            });

            if ($('#IsSave').val() == 'True') {
                var msg = $('#ErrorMsg').val();
                if (msg == '') {
                    jAlert('Save Success','Tip',function(){
                        OnClose(true);
                    });                    
                }
                else {
                    jAlert(msg);
                }
            }

            $('#somecontrolId').attr('readonly','true').addClass('readonly');

            $('select').each(function(){
                            $(this).val($(this).attr('_value'));
            });

            var validator = $('#editForm').validate({
                debug: true,       //调试模式取消submit的默认提交功能  
                errorClass: 'error', //默认为错误的样式类为：error  
                focusInvalid: false,
                onkeyup: false,
                submitHandler: function (form) {   //表单提交句柄,为一回调函数，带一个参数：form  
                    //alert('提交表单');
                    form.submit();   //提交表单  
                },
                rules: {           //定义验证规则,其中属性名为表单的name属性      
                    Name:{
                    },
                    SchoolId:{
                    },
                    Status:{
                    },
                    UserId:{
                    }

                },

                messages: {       //自定义验证消息  
                    PurchasePlan: {
                        //required: 'required !',
                        //minlength: $.format('用户名至少要{0}个字符！'),
                        //remote: $.format('{0}已经被占用')
                    },                   
                },
               errorPlacement: function (error, element) {
                    var noHtml = '<div class="notification error" for="' + error.attr('for') + '">' +
                            "<a class="close" ><img alt="close" title="Close this notification" src="/Content/images/cross_grey_small.png"></a>" +
                            '<div>' + error.html() + '</div>' + '</div>';
                    var notification = element.parent().find('div');
                    if (notification.length > 0) {
                        notification.remove();
                    }
                    element.parent().find('span').hide();
                    $(noHtml).appendTo(element.parent());
                    error.html('');
                    error.appendTo(element.parent());
                },
                highlight: function (element, errorClass) {  //针对验证的表单设置高亮  
                    //$(element).addClass(errorClass);
                },
                success: function (element) {
                    element.parent().find('span').show();
                    element.parent().find('div.error,label.validateError').remove();
                }});
        });
    </script>

}

@section css{
     
    <style type="text/css">   
    body
    {
        background: none;
    }
    .field
    {
        vertical-align: middle;
        clear: both;
        padding-left: 5px;
        padding-top: 5px;
        padding-bottom: 5px;
    }
    .field_name
    {
        width: 160px;
        float: left;
        padding-right: 10px;
        padding-top: 10px;
        margin: 0 auto;
    }
    .field_value
    {
        width: 260px;
        float: left;
    }
    custom-combobox input
    {
        width: 120px;
    }
    .operation
    {
        margin-top: 20px;
        padding-top: 20px;
        clear: both;
    }
    input
    {
        width: 206px;
    }
    select
    {
        width: 220px;
    }
    .readonly
    {
        background-color: #e6e6e6;
    }
    </style>

}

    <div class="tabmini-content">
        <form method="post" id="editForm" class="form" action="/xxx/EditPeopleItem">

    <input type='hidden' id='Id' name='Id' value='@Model.Id' />
    <input type='hidden' id='IsPostBack' name='IsPostBack' value='true' />    
    <input type='hidden' id='IsSave' name='IsSave' value='@Model.IsSave' />
    <input type='hidden' id='ErrorMsg' name='ErrorMsg' value='@Model.ErrorMsg' />

        <fieldset  class="ConfigArea">
            <div class="field">
                <div class="field_name">
                    <label>Name:</label>
                </div>
                <div class="field_value">
                    <input type="text" name="Name" id="Name" value="@Model.Name"/>
                </div>
            </div>
            <div class="field">
                <div class="field_name">
                    <label>SchoolId:</label>
                </div>
                <div class="field_value">
                    <input type="text" name="SchoolId" id="SchoolId" value="@Model.SchoolId"/>
                </div>
            </div>
            <div class="field">
                <div class="field_name">
                    <label>Status:</label>
                </div>
                <div class="field_value">
                    <input type="text" name="Status" id="Status" value="@Model.Status"/>
                </div>
            </div>
            <div class="field">
                <div class="field_name">
                    <label>UserId:</label>
                </div>
                <div class="field_value">
                    <input type="text" name="UserId" id="UserId" value="@Model.UserId"/>
                </div>
            </div>
        <div class='operation'>
            <a class='button blue' id='btnSaveAndClose'>Save&Close</a> <a class='button blue'
                id='btnCancel'>Cancel</a>
        </div>
        </fieldset>
    </form>
</div>

1.3.6.8 弹出生成MVC代码操作：

1.3.6.9 生成Action代码：

    public ActionResult EditPeople(EditPeopleModel model)
    {

        //model.UserId = Motorola.ZCH49.OaSystem.WebSite.Models.User.GetCurrentUser(this).Id;
        model.Action();
        return View(model);

    }

    [HttpPost]
    public ActionResult DeletePeople(Guid id)
    {
        var model = new ReturnInfo();

        if (id == default(Guid))
        {
            model.Message = "no id";
        }
        else
        {
             model = EditPeopleModel.DeletePeople(id);
        }
        return Json(model, JsonRequestBehavior.AllowGet);
        
    }

    [HttpPost]
    public ActionResult DeletePeople(List<Guid> idList)
    {
        var model = new ReturnInfo();

        if (idList == null || idList.Count == 0)
        {
            model.Message = "no id";
        }
        else
        {
             model = EditPeopleModel.DeletePeople(idList);
        }
        return Json(model, JsonRequestBehavior.AllowGet);
        
    }

1.3.7 视图的相关操作和表操作一样

1.4 自定义查询（解决常见查询动态参数化问题）

1.4.1 创建查询集（类似文件夹/目录概念，对查询进行管理）

1.4.2 创建查询

1.4.3 编辑查询

语法和语义同标准sql，主要用于动态的参数化查询，一下为一个常用查询的参数化（分页，各字段的排序，参数提取）

实例代码主要是EF查相关，其他的代码生成省略。

1.4.3.1 生成的查询条件类：

using System;
using System.Collections.Generic;

namespace xxx
{
    public class People_Query_Condition
    {
        public enum OrderByType
        {
            CreateTime_Asc,
            CreateTime_Desc,
            Id_Asc,
            Id_Desc,
            Name_Asc,
            Name_Desc,
            SchoolId_Asc,
            SchoolId_Desc,
            Status_Asc,
            Status_Desc,
            UpdateTime_Asc,
            UpdateTime_Desc,
            UserId_Asc,
            UserId_Desc,

        }

        public OrderByType? OrderBy { get; set; }

        public DateTime? CreateTime_Begin
        { get; set; }

        public DateTime? CreateTime_End
        { get; set; }

        public int? Id
        { get; set; }

        public List<int> Ids
        { get; set; }

        public string Name
        { get; set; }

        public int? SchoolId
        { get; set; }

        public int? Status
        { get; set; }

        public int? UserId
        { get; set; }


        public int PageIndex { get; set; }
        public int PageSize { get; set; }
        public int RecordCount { get; set; }
        public People_Query_Condition()
        {
            this.Ids = new List<int>();
        }
    }
}

1.4.3.2 生成的查询DTO类：

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace xxx
{
    [DataContract]
    public class People_Query_ConditionDto
    {
        [DataContract]
        public enum OrderByType
        {
            [EnumMember]
            CreateTime_Asc,
            [EnumMember]
            CreateTime_Desc,
            [EnumMember]
            Id_Asc,
            [EnumMember]
            Id_Desc,
            [EnumMember]
            Name_Asc,
            [EnumMember]
            Name_Desc,
            [EnumMember]
            SchoolId_Asc,
            [EnumMember]
            SchoolId_Desc,
            [EnumMember]
            Status_Asc,
            [EnumMember]
            Status_Desc,
            [EnumMember]
            UpdateTime_Asc,
            [EnumMember]
            UpdateTime_Desc,
            [EnumMember]
            UserId_Asc,
            [EnumMember]
            UserId_Desc,

        }

        [DataMember]
        public OrderByType? OrderBy { get; set; }

        [DataMember]
        public DateTime? CreateTime_Begin
        { get; set; }

        [DataMember]
        public DateTime? CreateTime_End
        { get; set; }

        [DataMember]
        public int? Id
        { get; set; }

        [DataMember]
        public List<int> Ids
        { get; set; }

        [DataMember]
        public string Name
        { get; set; }

        [DataMember]
        public int? SchoolId
        { get; set; }

        [DataMember]
        public int? Status
        { get; set; }

        [DataMember]
        public int? UserId
        { get; set; }

        [DataMember]
        public int PageIndex { get; set; }
        [DataMember]
        public int PageSize { get; set; }
        [DataMember]
        public int RecordCount { get; set; }
        public People_Query_ConditionDto()
        {
            this.Ids = new List<int>();
        }
    }
}

1.4.3.3 生成的EF规约代码：

public static ISpecification<People> People_Query(People_Query_Condition condition)
{
         ISpecification<People> id_spec = null;
         if (!condition.Id.HasValue)
         {
             id_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
         id_spec = new DirectSpecification<People>(x=>
             x.Id == condition.Id
         );
        }

         ISpecification<People> ids_spec = null;
         if (condition.Ids == null || condition.Ids.Count == 0)
         {
             ids_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
        }

         ISpecification<People> name_spec = null;
         if (string.IsNullOrWhiteSpace(condition.Name))
         {
              name_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
             name_spec = new DirectSpecification<People>(x=>
                  x.Name.Contains(condition.Name)
             );
        }

         ISpecification<People> schoolId_spec = null;
         if (!condition.SchoolId.HasValue)
         {
             schoolId_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
         schoolId_spec = new DirectSpecification<People>(x=>
             x.SchoolId == condition.SchoolId
         );
        }

         ISpecification<People> status_spec = null;
         if (!condition.Status.HasValue)
         {
             status_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
         status_spec = new DirectSpecification<People>(x=>
             x.Status == condition.Status
         );
        }

         ISpecification<People> userId_spec = null;
         if (!condition.UserId.HasValue)
         {
             userId_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
         userId_spec = new DirectSpecification<People>(x=>
             x.UserId == condition.UserId
         );
        }

         ISpecification<People> createTime_Begin_spec = null;
         if (!condition.CreateTime_Begin.HasValue)
         {
             createTime_Begin_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
         createTime_Begin_spec = new DirectSpecification<People>(x=>
             x.CreateTime >= condition.CreateTime_Begin
         );
        }

         ISpecification<People> createTime_End_spec = null;
         if (!condition.CreateTime_End.HasValue)
         {
             createTime_End_spec =  new DirectSpecification<People>(x=> true);
         }
         else{
         createTime_End_spec = new DirectSpecification<People>(x=>
             x.CreateTime <= condition.CreateTime_End
         );
        }

         var name_spec = new DirectSpecification<People>(x=>
             (x.Name??"") != ""
         );

         ISpecification<People> id_ids = new AndSpecification<People>(id_spec,ids_spec); 
         ISpecification<People> id_ids_name = new AndSpecification<People>(id_ids,name_spec); 
         ISpecification<People> id_ids_name_schoolId = new AndSpecification<People>(id_ids_name,schoolId_spec); 
         ISpecification<People> id_ids_name_schoolId_status = new AndSpecification<People>(id_ids_name_schoolId,status_spec); 
         ISpecification<People> id_ids_name_schoolId_status_userId = new AndSpecification<People>(id_ids_name_schoolId_status,userId_spec); 
         ISpecification<People> id_ids_name_schoolId_status_userId_createTime_Begin = new AndSpecification<People>(id_ids_name_schoolId_status_userId,createTime_Begin_spec); 
         ISpecification<People> id_ids_name_schoolId_status_userId_createTime_Begin_createTime_End = new AndSpecification<People>(id_ids_name_schoolId_status_userId_createTime_Begin,createTime_End_spec); 
         ISpecification<People> id_ids_name_schoolId_status_userId_createTime_Begin_createTime_End_name = new AndSpecification<People>(id_ids_name_schoolId_status_userId_createTime_Begin_createTime_End,name_spec); 
         return id_ids_name_schoolId_status_userId_createTime_Begin_createTime_End_name;
}

1.4.3.4 生成的EF存取代码：

public PageOfReturn<People> People_Query( People_Query_Condition condition )
{
     var data = this.GetAll( PeopleSpecification.People_Query(condition ));
     if( condition.OrderBy.HasValue )
     {
         switch(condition.OrderBy)
         {
         case People_Query_Condition.OrderByType.CreateTime_Asc:
             data = data.OrderBy(x=>x.CreateTime);
             break;
         case People_Query_Condition.OrderByType.CreateTime_Desc:
             data = data.OrderByDescending(x=>x.CreateTime);
             break;
         case People_Query_Condition.OrderByType.Id_Asc:
             data = data.OrderBy(x=>x.Id);
             break;
         case People_Query_Condition.OrderByType.Id_Desc:
             data = data.OrderByDescending(x=>x.Id);
             break;
         case People_Query_Condition.OrderByType.Name_Asc:
             data = data.OrderBy(x=>x.Name);
             break;
         case People_Query_Condition.OrderByType.Name_Desc:
             data = data.OrderByDescending(x=>x.Name);
             break;
         case People_Query_Condition.OrderByType.SchoolId_Asc:
             data = data.OrderBy(x=>x.SchoolId);
             break;
         case People_Query_Condition.OrderByType.SchoolId_Desc:
             data = data.OrderByDescending(x=>x.SchoolId);
             break;
         case People_Query_Condition.OrderByType.Status_Asc:
             data = data.OrderBy(x=>x.Status);
             break;
         case People_Query_Condition.OrderByType.Status_Desc:
             data = data.OrderByDescending(x=>x.Status);
             break;
         case People_Query_Condition.OrderByType.UpdateTime_Asc:
             data = data.OrderBy(x=>x.UpdateTime);
             break;
         case People_Query_Condition.OrderByType.UpdateTime_Desc:
             data = data.OrderByDescending(x=>x.UpdateTime);
             break;
         case People_Query_Condition.OrderByType.UserId_Asc:
             data = data.OrderBy(x=>x.UserId);
             break;
         case People_Query_Condition.OrderByType.UserId_Desc:
             data = data.OrderByDescending(x=>x.UserId);
             break;
         default:
             break;
         }
     }
     var result = new PageOfReturn<People>();
     result.RecordCount = data.Count();
     result.PageIndex = condition.PageIndex;
     result.PageSize = condition.PageSize;
     result.PageRecords = data.Skip(condition.PageSize * (condition.PageIndex - 1)).Take(condition.PageSize).ToList();
     return result;
}

1.4.3.5 其他层如Service，Web层。基本上代码少量改动一下就可以实现一个列表页面。实例代码省略

1.4.4 多表查询

1.4.4.1 生成的查询条件类：

using System;
using System.Collections.Generic;

namespace xxx
{
    public class GetPeopleInfo_Condition
    {
        public string SchoolName
        { get; set; }

        public int? Status
        { get; set; }


        public GetPeopleInfo_Condition()
        {
        }
    }
}

1.4.4.2 生成的查询条件DTO类：

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace xxx
{
    [DataContract]
    public class GetPeopleInfo_ConditionDto
    {
        [DataMember]
        public string SchoolName
        { get; set; }

        [DataMember]
        public int? Status
        { get; set; }

        public GetPeopleInfo_ConditionDto()
        {
        }
    }
}

1.4.4.3 生成的结果类：

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

namespace xxx
{
    public class PeopleInfo
    {
        public DateTime? CreateTime
        { get; set; }

        public int Id
        { get; set; }

        public string Name
        { get; set; }

        public int? SchoolId
        { get; set; }

        public int? Status
        { get; set; }

        public DateTime? UpdateTime
        { get; set; }

        public int? UserId
        { get; set; }

        public string SchoolName//来自表 School
        { get; set; }

        public string UserEmail //来自表 C_Users
        { get; set; }

    }
}

1.4.4.4 生成的EF代码（多表关联不再需要规约）：

public List<PeopleInfo> GetPeopleInfo( GetPeopleInfo_Condition condition )
{
     using (var unitOfWork = UnitOfWorkFactory.Create(DbOption.OA))
     {
     var p_q = ctx.Set<People>().AsQueryable();
     if(condition.Status != null )
     {
     p_q = p_q.Where(x=>x.Status == condition.Status);
     }

     var s_q = ctx.Set<School>().AsQueryable();
     if(condition.SchoolName != null )
     {
     s_q = s_q.Where(x=>x.Name == condition.SchoolName);
     }

     var u_q = ctx.Set<User>().AsQueryable();
     var q = p_q;

     var q_1 =     q.GroupJoin(s_q,p=>p.SchoolId,s=>s.Id,
             (p,s)=>new { p,s = s.DefaultIfEmpty() })
             .SelectMany(item=>item.s.Select(s=> new {item.p,s}));

     var q_2 =     q_1.GroupJoin(u_q,p=>p.p.UserId,u=>u.UserId,
             (p,u)=>new { p,u = u.DefaultIfEmpty() })
             .SelectMany(item=>item.u.Select(u=> new {item.p.p,item.p.s,u}));

     var q_final = q_2.Where(x=>
         true);

     var list = q_final.Select(x=>new PeopleInfo(){
         SchoolId = x.p.SchoolId,
         Name = x.p.Name,
         CreateTime = x.p.CreateTime,
         UpdateTime = x.p.UpdateTime,
         Id = x.p.Id,
         Status = x.p.Status,
         UserId = x.p.UserId,
         SchoolName = x.SchoolName,
         UserEmail = x.UserEmail,
     });
     return list.ToList();
     }
}

1.4.5 高级查询

1.4.5.1 分组查询

1.4.5.2 选项查询

1.4.5.2.1 {'op','all'} 一个字段产生多个查询条件

1.4.5.2.2 对条件查询进行条件：在某些参数非空下区域内参数才有效

写这么多，感觉需要控制篇幅，查询告一段落～

1.5 反向工程（持久阶段元数据更新设计阶段元数据）

使设计永不过期

  ----------->

1.6 生成数据词典

  ----------->

终于码完了。

2. 总结：

　　生成器基本上涉及了数据系统资源管理的方方面面（数据操作，应用层，服务层，展现层），能节约大量的开发时间。使工程师更注重业务知识，

举例来说，用来这套开发工具后，我们团队加班变得非常少，项目进度和预期的基本吻合。拙笔仓促，如有笔误和不妥请谅解，希望听到大家的意见和建议，thanks。