项目中需要使用支持Postgresql的ORM代码生成工具，搜寻了几个常用工具进行了考察，考察的原则是“支持Postgresql、易于使用”，最终选择了EntitysCodeGenerate。

考察结果如下：

动软代码生成器

下载地址：http://www.maticsoft.com/download.aspx
使用版本：2.78（2013-3-12）
支持数据库：sql Server，Oracle，MysqL，OleDb，sqlite
参考资料：动软代码生成器帮助中心
存在问题：不支持Postgresql

MyGeneration

下载地址：http://sourceforge.net/projects/mygeneration/files/
使用版本：1.3.1（2011-1-2） && 1.3.0.9（2008-10-6）
支持数据库：sql Server，Oracle，IBM DB2，Microsoft Access，MysqL，Postgresql，Firebird，Interbase，sqlite，VistaDB，Advantage，IBM iSeries，CSV & other delimited text files
缺点：只支持单表，复杂的查询还要先写视图。
参考资料：
    代码自动生成工具MyGeneration之一-程序员必备工具
    MyGeneration：使用dOOdad提供的通用操作
    强大的代码生成工具MyGeneration
存在问题：无法使用（操作系统为 Win7 64 位）
    安装mygeneration_131_20110102.exe，成功配置，连接数据库成功，但是无法生成代码。
    安装mygeneration_1309_20081006.exe，配置时驱动列表为空，无法使用。
    安装过程的问题处理：
        You cannot run MyGeneration without having MDAC 2.7+ installed. It is not included in the installer because the file is large and most people already have it installed.
            处理方法：安装时去掉Detect MDAC 2.7+选项
            参考：win7 64 下安装MyGeneration 遇到的问题解决方法
        驱动列表为空
            处理方法： 修改RegisterMyMeta.bat文件，将框架v2.0.50727修改为v4.0.30319
            参考：MyGeneration 1.3 配置界面driver下拉列表为空的解决办法
            处理结果：无效

Keelkit

下载地址：http://keelkit.codeplex.com/releases/view/88378
使用版本：3.0.7600.638（2012-5-25）
支持数据库：Microsoft Access，sql Server，MysqL，Oracle
参考资料：KeelKit系列文章（二）：快速配置（相关资料极少）
存在问题：不支持Postgresql
其他问题：不支持 VS2013

Gentle.NET

下载地址：http://sourceforge.net/projects/gopf/?source=typ_redirect
使用版本：1.5.0（2013-4-3）
支持数据库：Firebird，Jet，MysqL，Postgresql，Oracle，OracleODP，sqlite，sql Server
参考资料：
    Gentle.NET初探
        其中用到了CodeSmith生成代码
            下载地址：CodeSmith 7，最新绿色破解版，带注册机
            破解方法：CodeSmith 7.01破解下载
    GENTLE.NET快速上手
存在问题：在编辑GentleBusinessObject.cst文件的SourceTable参数时，无法指定Postgresql数据源（可能是需要自己按照GentleBusinessObject.cst文件编写对应的配置。
其他问题：Gentle.NET的使用方式是，先利用CodeSmith等生成最基本的Model（无增删查改的方法），再使用Gentle.Framework.Broker对Model进行增删查改。配置上比较复杂，CodeSmith一次只能生成一个数据表，用起来不太方便。

EntitysCodeGenerate

下载地址：http://www.downxia.com/downinfo/26449.html#softdown
使用版本：4.6（2014-5-5）
支持数据库：Oracle，sql Server，Access，MysqL，Sybase，sqlite，DB2，OleDb，Postgresql，DM（达梦），PowerDesigner
参考资料：ORM框架-VB/C#.Net实体代码生成工具(EntitysCodeGenerate)【ECG 4.2】的相关使用
测试结果：成功，生成的代码示例如下：

/****************************************** * 模块名称：实体 role * 当前版本：1.0 * 开发人员：Administrator * 生成时间：2015/7/8 * 版本历史：此代码由 VB/C#.Net实体代码生成工具(EntitysCodeGenerate 4.6) 自动生成。 * ******************************************/
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Xml;
using System.IO;
using System.Text;
using System.Database;
using System.Database.ORMap;
using System.Database.Extend;

namespace ZHD.GIS.Entity
{
    /// <summary>
    /// 实体 role
    /// </summary>
    [Description("Primary:id")]
    [Serializable]
    public partial class role : BaseEntity
    {
        #region 构造函数
        /// <summary>
        /// 实体 role
        /// </summary>
        public role(){}
        /// <summary>
        /// 实体 role
        /// </summary>
        /// <param name="keyValue">主键id对应的值</param>
        public role(object keyValue)
        {
            ListDictionary list = new ListDictionary();
            list.Add("id",keyValue);
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,this);
            ormap.GetEntity(list);
        }
        /// <summary>
        /// 实体 role
        /// </summary>
        /// <param name="colName">实体字段名</param>
        /// <param name="colValue">实体字段名(colName)匹配相等的值</param>
        public role(string colName,object colValue)
        {
            ListDictionary list = new ListDictionary();
            list.Add(colName,colValue);
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,this);
            ormap.GetEntity(list);
        }
        /// <summary>
        /// 实体 role
        /// </summary>
        /// <param name="colNames">实体字段名数组</param>
        /// <param name="colValues">实体字段名数组(colNames)匹配相等的值</param>
        public role(string[] colNames,object[] colValues)
        {
            if (colNames.Length == colValues.Length)
            {
                ListDictionary list = new ListDictionary();
                for (int i = 0; i < colNames.Length; i++)
                {
                    list.Add(colNames[i],colValues[i]);
                }
                ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,this);
                ormap.GetEntity(list);
            }
        }
        /// <summary>
        /// 实体 role
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务)</param>
        /// <param name="colName">实体字段名</param>
        /// <param name="colValue">实体字段名(colName)匹配相等的值</param>
        public role(DbCore dbCore,string colName,this);
            ormap.GetEntity(dbCore,list);
        }
        /// <summary>
        /// 实体 role
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务)</param>
        /// <param name="colNames">实体字段名数组</param>
        /// <param name="colValues">实体字段名数组(colNames)匹配相等的值</param>
        public role(DbCore dbCore,string[] colNames,this);
                ormap.GetEntity(dbCore,list);
            }
        }
        #endregion

        #region 私有变量
        private string _id = null;
        private string _name = null;
        private string _comment = null;
        #endregion

        #region 公共属性
        /// <summary>
        /// 主键 id(NOT NULL)
        /// </summary>
        [DataObjectField(true)]
        public string id
        {
            set{ _id=value;}
            get{return _id;}
        }
        /// <summary>
        /// name(NOT NULL)
        /// </summary>
        [DataObjectField(false)]
        public string name
        {
            set{ _name=value;}
            get{return _name;}
        }
        /// <summary>
        /// comment
        /// </summary>
        [DataObjectField(false)]
        public string comment
        {
            set{ _comment=value;}
            get{return _comment;}
        }
        #endregion

        #region 常用 增、删、改、查 操作(注：.Net下数值型字段初始值默认为0;带?的数值型字段值默认为null.)

        #region public override int DelInsert/DelInsertEx 扩展方法
        /// <summary>
        /// 先Delete后Insert 比较实体前后默认的初始值,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public override int DelInsert()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this);
            return ormap.DelInsert(new role());
        }
        /// <summary>
        /// 先Delete后Insert 插入所有字段,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public override int DelInsertEx()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this);
            return ormap.DelInsertEx(new role());
        }
        #endregion

        #region public override int Insert 增加
        /// <summary>
        /// 通过实体映射插入表中一条数据，插入与初始值不同的字段
        /// </summary>
        /// <returns>执行插入数据并返回受影响的行数</returns>
        public override int Insert()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this);
            return ormap.Insert(new role());
        }
        #endregion

        #region public override int Update 更新
        /// <summary>
        /// 通过实体映射及主键约束更新表中一条数据，并与比较实体初始值比较，若内容不同则更新之，否则不更新(并与实体默认初始值比较确定更新哪些字段,与默认初始值一样的字段将不更新)
        /// </summary>
        /// <returns>执行更新并返回受影响的行数</returns>
        public override int Update()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this);
            return ormap.Update(new role());
        }
        #endregion

        #region public override int Save 保存 规则：按主键判断有就更新，没有就插入，且不保存与实体初始值相同的字段值
        /// <summary>
        /// 保存 比较实体前后的值，若有与主键记录相同的就更新，没有就插入，且不保存与实体初始值相同的字段值
        /// </summary>
        /// <returns>执行更新或插入数据操作并返回受影响的行数</returns>
        public override int Save()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this);
            return ormap.Save1(new role());
        }
        #endregion

        #region public role GetEntity 获取实体信息
        /// <summary>
        /// 通过实体映射及主键值获取表中一条数据信息
        /// </summary>
        /// <returns>返回类型为 Entity 单条实体信息(若符合条件的记录多条，则返回第一条)，没有为null</returns>
        public role GetEntity()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.GetEntity() as role;
        }
        /// <summary>
        /// 通过实体映射及主键值获取表中一条数据信息
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例</param>
        /// <returns>返回类型为 Entity 单条实体信息(若符合条件的记录多条，则返回第一条)，没有为null</returns>
        public role GetEntity(DbCore dbCore)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.GetEntity(dbCore) as role;
        }
        /// <summary>
        /// 通过Hashtable键值实体条件获取表中一条数据信息
        /// </summary>
        /// <param name="hash">获取实体信息的条件值</param>
        /// <returns>返回类型为 Entity 单条实体信息(若符合条件的记录多条，则返回第一条)，没有为null</returns>
        public role GetEntity(Hashtable hash)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(new role(),new role());
            return ormap.GetEntity(hash) as role;
        }
        /// <summary>
        /// 根据ListDictitionary键值实体条件值获取实体信息,通常包含 10 个或 10 个以下项的集合,建议这时使用
        /// </summary>
        /// <param name="list">获取实体信息的条件值</param>
        /// <returns>返回类型为 Entity 单条实体信息(若符合条件的记录多条，则返回第一条)，没有为null</returns>
        public role GetEntity(ListDictionary list)
        {;
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(new role(),new role());
            return ormap.GetEntity(list) as role;
        }
        #endregion

        #region public int SaveByEntityCondition 保存 规则：按当前实体唯一条件值判断有就更新，没有就插入，且不保存与实体初始值相同的字段值
        /// <summary>
        /// 用于没有主键表的辅助方法，有主键表的建议使用Save()
        /// 保存 比较实体前后的值，若有与现在实体唯一记录相同的就更新，没有就插入，且不保存与实体初始值相同的字段值
        /// 前提条件当前实体字段所赋值必须唯一，否则获取记录为多条返回多条更新将会产生不正确的结果，更新多条记录等问题
        /// </summary>
        /// <param name="entityCondition">更新或插入的实体唯一条件</param>
        /// <returns>执行更新或插入数据操作并返回受影响的行数</returns>
        public int SaveByEntityCondition(role entityCondition)
        {
            role entity = new role();
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,entity);
            return ormap.SaveByAny(entity,entityCondition);
        }
        #endregion

        #region public role GetEntityByEntityCondition 通过实体值获取一条实体信息
        /// <summary>
        /// 用于没有主键表的辅助方法，有主键表的建议使用GetEntity()
        /// 通过实体信息并与实体初始值的比较，凡与初始值比较不同的值作为实体的获取条件，返回相应的一条实体信息
        /// </summary>
        /// <returns>返回类型为 Entity 单条实体信息(若符合条件的记录多条，则返回第一条),没有返回为null</returns>
        public role GetEntityByEntityCondition()
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.GetEntityByAny() as role;
        }
        #endregion

        #endregion

        #region public role FromXml 相关Xml操作
        /// <summary>
        /// 通过与持久化实体信息相对应Xml格式的文本信息实例化到该实体信息
        /// </summary>
        /// <param name="xmlString">与持久化实体信息相对应Xml格式的文本信息</param>
        /// <returns>返回对应的实体信息</returns>
        public role FromXml(string xmlString)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.FromXml(xmlString) as role;
        }
        /// <summary>
        /// 通过与持久化实体信息相对应Xml格式的文本信息实例化到该实体信息
        /// </summary>
        /// <param name="filename">文件的 URL，该文件包含要加载的 XML 文档。URL 既可以是本地文件，也可以是 HTTP URL（Web 地址）。</param>
        /// <returns>实例化该实体信息并与持久化实体信息相对应xmlString文本信息一致</returns>
        public role FromXmlFile(string filename)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.FromXmlFile(filename) as role;
        }
        #endregion

        #region public role FromString 通过与持久化实体信息相对应的字符串拼接文本信息实例化到该实体信息
        /// <summary>
        /// 通过与持久化实体信息相对应的字符串拼接文本信息实例化到该实体信息
        /// </summary>
        /// <param name="entityString">与持久化实体信息相对应的字符串拼接文本信息</param>
        /// <returns>返回对应的实体信息</returns>
        public role FromString(string entityString)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.FromEntityString(entityString) as role;
        }
        #endregion

        #region public role FromJSON 通过与持久化实体信息相对应的JSON格式信息实例化到该实体信息
        /// <summary>
        /// 通过与持久化实体信息相对应的JSON格式文本信息实例化到该实体信息
        /// </summary>
        /// <param name="jsonString">JSON格式的实体信息</param>
        /// <returns>返回实例化后的实体信息并与JSON格式文本信息保持一致</returns>
        public role FromJSON(string jsonString)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.FromJSON(jsonString) as role;
        }
        /// <summary>
        /// 通过与持久化实体信息相对应的Json文本信息实例化到该实体信息
        /// </summary>
        /// <param name="jsonString">Json格式的实体文本信息</param>
        /// <param name="formatting">Json格式设置选项</param>
        /// <returns>返回实例化后的实体信息并与JSON文本信息保持一致</returns>
        public role FromJson(string jsonString,System.Database.Provider.JsonFormatting formatting)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.FromJson(jsonString,formatting) as role;
        }
        #endregion

        #region public role FromDataRow 通过与实体信息相对应的 DataRow 实例化到实体信息
        /// <summary>
        /// 通过与实体信息相对应的 DataRow 实例化到实体信息
        /// </summary>
        /// <param name="dr">与实体信息相对应的 DataRow</param>
        /// <returns>返回实例化后的实体信息并与 DataRow 信息一致</returns>
        public role FromDataRow(System.Data.DataRow dr)
        {
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this,new role());
            return ormap.FromDataRow(dr) as role;
        }
        #endregion

        #region 公共静态只读属性
        /// <summary>
        /// 表名 表原信息描述: role
        /// </summary>
        public static readonly string s_TableName =  "role";
        /// <summary>
        /// 信息描述: id(NOT NULL)
        /// </summary>
        public static readonly string s_id =  "role┋id┋System.String";
        /// <summary>
        /// 信息描述: name(NOT NULL)
        /// </summary>
        public static readonly string s_name =  "role┋name┋System.String";
        /// <summary>
        /// 信息描述: comment
        /// </summary>
        public static readonly string s_comment =  "role┋comment┋System.String";
        #endregion
    }

    /// <summary>
    /// role实体集
    /// </summary>
    [Serializable]
    public class roleS : CollectionBase
    {
        #region 构造函数
        /// <summary>
        /// role实体集
        /// </summary>
        public roleS(){}
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="blnRetrieveData">是否获取所有数据到实体集对象的标示(true获取所有实例信息,false仅实例化对象)</param>
        public roleS(bool blnRetrieveData)
        {
            if (blnRetrieveData)
            {
                ORMaps<BaseEntity,roleS> ormaps = new ORMaps<BaseEntity,roleS>(new role(),this);
                ormaps.GetEntitys(new ListDictionary());
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="blnRetrieveData">是否获取所有数据到实体集对象的标示(true获取所有实例信息,false及实例化对象)</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(bool blnRetrieveData,string[] orderColumns,OrderDirection[] orderDirections)
        {
            if (blnRetrieveData)
            {
                ORMaps<BaseEntity,this);
                ormaps.GetEntitys(new ListDictionary(),new Operation[] { },orderColumns,orderDirections);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colName">实体字段名</param>
        /// <param name="colValue">实体字段名匹配相等的值</param>
        public roleS(string colName,object colValue)
        {
            ListDictionary listColAndValue = new ListDictionary();
            listColAndValue.Add(colName,colValue);
            ORMaps<BaseEntity,this);
            ormaps.GetEntitys(listColAndValue);
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colName">实体字段名</param>
        /// <param name="operate">比较操作符</param>
        /// <param name="colValue">实体字段名对应的值</param>
        public roleS(string colName,Operation operate,this);
            ormaps.GetEntitys(listColAndValue,operate);
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colName">实体字段名</param>
        /// <param name="operate">比较操作符</param>
        /// <param name="colValue">实体字段名对应的值</param>
        /// <param name="orderColumn">排序字段</param>
        /// <param name="orderDirection">对应排序方向</param>
        public roleS(string colName,object colValue,string orderColumn,OrderDirection orderDirection)
        {
            ListDictionary listColAndValue = new ListDictionary();
            listColAndValue.Add(colName,new Operation[] { operate },new string[] { orderColumn },new OrderDirection[] { orderDirection });
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colName">实体字段名</param>
        /// <param name="operate">比较操作符</param>
        /// <param name="colValue">实体字段名对应的值</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(string colName,OrderDirection[] orderDirections)
        {
            ListDictionary listColAndValue = new ListDictionary();
            listColAndValue.Add(colName,orderDirections);
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colNames">实体字段名数组</param>
        /// <param name="colValues">实体字段名数组匹配相等的值</param>
        public roleS(string[] colNames,object[] colValues)
        {
            if (colNames.Length == colValues.Length)
            {
                ListDictionary listColAndValue = new ListDictionary();
                for (int i = 0; i < colNames.Length; i++)
                {
                    listColAndValue.Add(colNames[i],colValues[i]);
                }
                ORMaps<BaseEntity,this);
                ormaps.GetEntitys(listColAndValue);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colNames">实体字段名数组</param>
        /// <param name="operates">比较操作符数组</param>
        /// <param name="colValues">实体字段名数组对应的值</param>
        /// <param name="orderColumns">排序字段数组</param>
        public roleS(string[] colNames,Operation[] operates,object[] colValues,string[] orderColumns)
        {
            if (colNames.Length == operates.Length && colNames.Length == colValues.Length)
            {
                ListDictionary listColAndValue = new ListDictionary();
                for (int i = 0; i < colNames.Length; i++)
                {
                    listColAndValue.Add(colNames[i],this);
                ormaps.GetEntitys(listColAndValue,operates,orderColumns);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="colNames">实体字段名数组</param>
        /// <param name="operates">比较操作符数组</param>
        /// <param name="colValues">实体字段名数组对应的值</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(string[] colNames,OrderDirection[] orderDirections)
        {
            if (colNames.Length == operates.Length && colNames.Length == colValues.Length)
            {
                ListDictionary listColAndValue = new ListDictionary();
                for (int i = 0; i < colNames.Length; i++)
                {
                    listColAndValue.Add(colNames[i],orderDirections);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="listColAndValue">实体字段名及对应匹配相等的值</param>
        public roleS(ListDictionary listColAndValue)
        {
            ORMaps<BaseEntity,this);
            ormaps.GetEntitys(listColAndValue);
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="listColAndValue">实体字段名及对应匹配的值</param>
        /// <param name="operates">实体字段名对应比较操作符</param>
        public roleS(ListDictionary listColAndValue,Operation[] operates)
        {
            if (listColAndValue.Count == operates.Length)
            {
                ORMaps<BaseEntity,operates);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="listColAndValue">实体字段名及对应匹配的值</param>
        /// <param name="operates">实体字段名对应比较操作符</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(ListDictionary listColAndValue,OrderDirection[] orderDirections)
        {
            if (listColAndValue.Count == operates.Length)
            {
                ORMaps<BaseEntity,orderDirections);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="orderColumn">排序字段</param>
        /// <param name="orderDirection">排序方向</param>
        public roleS(string orderColumn,OrderDirection orderDirection)
        {
            ORMaps<BaseEntity,this);
            ormaps.GetEntitys(new ListDictionary(),new OrderDirection[] { orderDirection });
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(string[] orderColumns,OrderDirection[] orderDirections)
        {
            ORMaps<BaseEntity,orderDirections);
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务)</param>
        /// <param name="listColAndValue">实体字段名及对应匹配的值</param>
        /// <param name="operates">实体字段名对应比较操作符</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(DbCore dbCore,ListDictionary listColAndValue,this);
                ormaps.GetEntitys(dbCore,listColAndValue,orderDirections);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务)</param>
        /// <param name="colNames">实体字段名数组</param>
        /// <param name="operates">实体字段名对应比较操作符</param>
        /// <param name="colValues">实体字段名数组对应的值</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(DbCore dbCore,orderDirections);
            }
        }
        #endregion

        #region 属性方法
        /// <summary>
        /// role集合 增加方法
        /// </summary>
        public void Add(role entity)
        {
            this.List.Add(entity);
        }
        /// <summary>
        /// role集合 索引
        /// </summary>
        public role this[int index]
        {
            get { return (role)this.List[index]; }
            set { this.List[index] = value; }
        }
        /// <summary>
        /// 将role实体集转化到内存中一个数据表
        /// </summary>
        /// <returns>与实体集数据对等的内存中一个数据表</returns>
        public System.Data.DataTable ToDataTable()
        {
            ORMaps<BaseEntity,this);
            return ormaps.ToDataTable();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值(并与实体默认初始值比较确定保存哪些字段)，若有与主键记录相同的就更新，没有就插入
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务,执行命令先打开(Open)数据库连接)</param>
        /// <returns>受影响的行数</returns>
        public int Save(DbCore dbCore)
        {
            int intRecord = 0;
            foreach (role entity in this)
            {
                intRecord += entity.Save(dbCore);
            }
            return intRecord;
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值，若有与主键字段记录相同的就更新，没有就插入，保存全部字段
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务,执行命令先打开(Open)数据库连接)</param>
        /// <returns>受影响的行数</returns>
        public int SaveAll(DbCore dbCore)
        {
            int intRecord = 0;
            foreach (role entity in this)
            {
                intRecord += entity.SaveAll(dbCore);
            }
            return intRecord;
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值，若有与主键字段记录相同的就更新，没有就插入，保存全部字段
        /// 其中若与实体属性字段初始值相同则置该字段为空
        /// </summary>
        /// <param name="dbCore">数据库访问核心类DbCore实例(用于DbCore事务,执行命令先打开(Open)数据库连接)</param>
        /// <returns>受影响的行数</returns>
        public int SaveEx(DbCore dbCore)
        {
            int intRecord = 0;
            foreach (role entity in this)
            {
                intRecord += entity.SaveEx(dbCore);
            }
            return intRecord;
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值(并与实体默认初始值比较确定保存哪些字段)，若有与主键记录相同的就更新，没有就插入
        /// </summary>
        /// <returns>受影响的行数</returns>
        public int Save()
        {
            ORMaps<BaseEntity,this);
            return ormaps.Save();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值，若有与主键字段记录相同的就更新，没有就插入，保存全部字段
        /// </summary>
        /// <returns>受影响的行数</returns>
        public int SaveAll()
        {
            ORMaps<BaseEntity,this);
            return ormaps.SaveAll();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值，若有与主键字段记录相同的就更新，没有就插入，保存全部字段
        /// 其中若与实体属性字段初始值相同则置该字段为空
        /// </summary>
        /// <returns>受影响的行数</returns>
        public int SaveEx()
        {
            ORMaps<BaseEntity,this);
            return ormaps.SaveEx();
        }
        /// <summary>
        /// 通过实体集中的对象信息映射及主键约束批量删除实体集对应表中的多条数据
        /// </summary>
        /// <returns>执行删除并返回受影响的行数</returns>
        public int Delete()
        {
            ORMaps<BaseEntity,this);
            return ormaps.Delete();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 比较实体前后默认的初始值,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsert()
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsert();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <param name="strConditionKey"></param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsert(string strConditionKey)
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsert(strConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <param name="arrConditionKey">指定作为Delete依据字段,一个或多个,可以使用对应的EntityColumn属性</param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsert(string[] arrConditionKey)
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsert(arrConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertEx()
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsertEx();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <param name="strConditionKey"></param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertEx(string strConditionKey)
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsertEx(strConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <param name="arrConditionKey">指定作为Delete依据字段,可以使用对应的EntityColumn属性</param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertEx(string[] arrConditionKey)
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsertEx(arrConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertAll()
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsertAll();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段
        /// </summary>
        /// <param name="strConditionKey"></param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertAll(string strConditionKey)
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsertAll(strConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段
        /// </summary>
        /// <param name="arrConditionKey">指定作为Delete依据字段,可以使用对应的EntityColumn属性</param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertAll(string[] arrConditionKey)
        {
            ORMaps<BaseEntity,this);
            return ormaps.DelInsertAll(arrConditionKey);
        }
        /// <summary>
        /// 将持久化实体集信息输出成Xml格式文本信息(不含DataType属性)
        /// </summary>
        /// <returns>与持久化实体集信息相对应Xml的文本信息</returns>
        public string ToXml()
        {
            return this.ToXml(Formatting.None);
        }
        /// <summary>
        /// 将持久化实体集信息输出成Xml格式文本信息(不含DataType属性)
        /// </summary>
        /// <param name="xmlFormatting">指定 System.Xml.XmlTextWriter 的格式设置选项</param>
        /// <returns>与持久化实体集信息相对应Xml指定格式化后的文本信息(不含DataType属性)</returns>
        public string ToXml(Formatting xmlFormatting)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            string strName = "roleS";
            sb.AppendLine("<" + strName + ">");
            foreach (role e in this)
            {
                sb.AppendLine(e.ToXml(xmlFormatting));
            }
            sb.AppendLine("</" + strName + ">");
            return sb.ToString();
        }
        /// <summary>
        /// 将持久化实体集信息输出成Xml格式信息并写入到文件(不含DataType属性)
        /// </summary>
        /// <param name="filename">要写入的文件名。如果目标文件已存在，则覆盖该文件。</param>
        /// <param name="encoding">一个 System.Text.Encoding 对象，表示应用于字符串的编码。</param>
        /// <param name="xmlFormatting">指定 System.Xml.XmlTextWriter 的格式设置选项</param>
        public void ToXml(string filename,Encoding encoding,Formatting xmlFormatting)
        {
            string xmlString = this.ToXml(xmlFormatting);
            File.WriteAllText(filename,xmlString,encoding);
        }
        /// <summary>
        /// 将持久化实体集信息输出成Xml格式文本信息(含DataType属性)
        /// </summary>
        /// <param name="xmlFormatting">指定 System.Xml.XmlTextWriter 的格式设置选项</param>
        /// <returns>与持久化实体集信息相对应Xml指定格式化后的文本信息</returns>
        public string ToXml_(Formatting xmlFormatting)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            string strName = "roleS";
            sb.AppendLine("<" + strName + ">");
            foreach (role e in this)
            {
                sb.AppendLine(e.ToXml_(xmlFormatting));
            }
            sb.AppendLine("</" + strName + ">");
            return sb.ToString();
        }
        /// <summary>
        /// 将持久化实体集信息输出成Xml格式信息并写入到文件(含DataType属性)
        /// </summary>
        /// <param name="filename">要写入的文件名。如果目标文件已存在，则覆盖该文件。</param>
        /// <param name="encoding">一个 System.Text.Encoding 对象，表示应用于字符串的编码。</param>
        /// <param name="xmlFormatting">指定 System.Xml.XmlTextWriter 的格式设置选项</param>
        public void ToXml_(string filename,Formatting xmlFormatting)
        {
            string xmlString = this.ToXml_(xmlFormatting);
            File.WriteAllText(filename,encoding);
        }
        /// <summary>
        /// 通过与持久化实体集信息相对应Xml格式的文本信息实例化到该实体集
        /// </summary>
        /// <param name="xmlString"></param>
        /// <returns>实例化该实体集信息并与持久化实体信息相对应xmlString文本信息一致</returns>
        public roleS FromXml(string xmlString)
        {
            int index = 0;
            string strSubXml = string.Empty;
            this.Clear();
            while (index != -1) 
            {
                index = CommonHelp.GetSubXmlString(xmlString,"role",index,out strSubXml);
                if (strSubXml != string.Empty)
                {
                    role entity = new role();
                    entity = entity.FromXml(strSubXml);
                    this.Add(entity);
                }
                else
                {
                    break;
                }
            }
            return this;
        }
        /// <summary>
        /// 通过与持久化实体集信息相对应Xml格式的文本信息实例化到该实体集
        /// </summary>
        /// <param name="filename">要打开以进行读取的文件</param>
        /// <returns>实例化该实体集信息并与持久化实体信息相对应xmlString文本信息一致</returns>
        public roleS FromXmlFile(string filename)
        {
            string xmlString = File.ReadAllText(filename);
            return this.FromXml(xmlString);
        }
        /// <summary>
        /// 通过与持久化实体集信息相对应Xml格式的文本信息实例化到该实体集
        /// </summary>
        /// <param name="filename">要打开以进行读取的文件</param>
        /// <param name="encoding">应用到文件内容的编码。</param>
        /// <returns>实例化该实体集信息并与持久化实体信息相对应xmlString文本信息一致</returns>
        public roleS FromXmlFile(string filename,Encoding encoding)
        {
            string xmlString = File.ReadAllText(filename,encoding);
            return this.FromXml(xmlString);
        }
        /// <summary>
        /// 将持久化实体集信息输出成JSON格式信息
        /// </summary>
        /// <returns>与持久化实体集信息相同的JSON格式信息</returns>
        public string ToJSON()
        {
            StringBuilder sb = new StringBuilder();
            foreach (role e in this)
            {
                sb.AppendLine(e.ToJSON() + ",");
            }
            return "[" + sb.ToString().TrimEnd(new char[] { '\n','\r',',' }) + "]";
        }
        /// <summary>
        /// 将持久化实体集信息输出成JSON格式的文本信息
        /// </summary>
        /// <param name="formatting">Json格式设置选项</param>
        /// <returns>与持久化实体集信息相同的JSON文本信息</returns>
        public string ToJson(System.Database.Provider.JsonFormatting formatting)
        {
            StringBuilder sb = new StringBuilder();
            foreach (role e in this)
            {
                sb.AppendLine(e.ToJson(formatting) + ",' }) + "]";
        }
        /// <summary>
        /// 通过与持久化实体集信息相对应的JSON格式信息实例化到该实体集信息
        /// </summary>
        /// <param name="jsonString">JSON格式的实体集信息</param>
        /// <returns>返回实例化后的实体集信息并与JSON格式文本信息保持一致</returns>
        public roleS FromJSON(string jsonString)
        {
            string[] arrayJson = jsonString.Trim(new char[] { '\n',' ' }).TrimStart('[').TrimEnd(']').Replace("}\r\n,","},").Split(new string[] { "}," },StringSplitOptions.RemoveEmptyEntries);
            this.Clear();
            foreach(string str in arrayJson)
            {
                role entity = new role();
                entity = entity.FromJSON(str);
                this.Add(entity);
            }
            return this;
        }
        /// <summary>
        /// 通过与持久化实体集信息相对应的JSON格式文本信息实例化到该实体集信息
        /// </summary>
        /// <param name="jsonString">JSON格式的实体集信息</param>
        /// <param name="formatting">Json格式设置选项</param>
        /// <returns>返回实例化后的实体集信息并与JSON格式文本信息保持一致</returns>
        public roleS FromJson(string jsonString,System.Database.Provider.JsonFormatting formatting)
        {
            string[] arrayJson = jsonString.Trim(new char[] { '\n',StringSplitOptions.RemoveEmptyEntries);
            this.Clear();
            foreach (string str in arrayJson)
            {
                role entity = new role();
                entity = entity.FromJson(str,formatting);
                this.Add(entity);
            }
            return this;
        }
        /// <summary>
        /// 将持久化实体集信息输出成String格式信息
        /// </summary>
        /// <returns>与实体集信息相同的String格式信息</returns>
        public override string ToString()
        {
            string strEntitys = String.Empty;
            foreach (role e in this)
            {
                strEntitys += e.ToString() + "┋┋";
            }
            return strEntitys.TrimEnd('┋');
        }
        /// <summary>
        /// 通过与实体集信息相对应的String格式信息实例化到该实体集信息
        /// </summary>
        /// <param name="entitysString">与实体集信息相同的String格式信息</param>
        /// <returns>返回实例化后的实体集信息并与String格式信息保持一致</returns>
        public roleS FromString(string entitysString)
        {
            this.Clear();
            string[] arrayString = entitysString.Split(new string[] { "┋┋" },StringSplitOptions.RemoveEmptyEntries);
            foreach (string str in arrayString)
            {
                role entity = new role();
                entity = entity.FromString(str);
                this.Add(entity);
            }
            return this;
        }
        /// <summary>
        /// 通过与实体集信息相对应的 DataTable 实例化到实体集信息
        /// </summary>
        /// <param name="dtbl">与实体集信息相同的 DataTable 信息</param>
        /// <returns>返回实例化后的实体集信息并与 DataTable 信息一致</returns>
        public roleS FromDataTable(System.Data.DataTable dtbl)
        {
            this.Clear();
            foreach (System.Data.DataRow dr in dtbl.Rows)
            {
                role entity = new role();
                entity = entity.FromDataRow(dr);
                this.Add(entity);
            }
            return this;
        }
        #endregion
    }
}