PostgreSQL 代码生成工具选择

原创 2015年07月08日 14:15:42

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

考察结果如下:


动软代码生成器


MyGeneration


Keelkit


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
  • 参考资料:
  • 存在问题:在编辑GentleBusinessObject.cst文件的SourceTable参数时,无法指定PostgreSQL数据源(可能是需要自己按照GentleBusinessObject.cst文件编写对应的配置。
  • 其他问题:Gentle.NET的使用方式是,先利用CodeSmith等生成最基本的Model(无增删查改的方法),再使用Gentle.Framework.Broker对Model进行增删查改。配置上比较复杂,CodeSmith一次只能生成一个数据表,用起来不太方便。

EntitysCodeGenerate

/******************************************
* 模块名称:实体 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, object colValue)
        {
            ListDictionary list = new ListDictionary();
            list.Add(colName, colValue);
            ORMap<BaseEntity> ormap = new ORMap<BaseEntity>(this, 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, 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(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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(),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,object colValue)
        {
            ListDictionary listColAndValue = new ListDictionary();
            listColAndValue.Add(colName, colValue);
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(),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, Operation operate, object colValue, string orderColumn, OrderDirection orderDirection)
        {
            ListDictionary listColAndValue = new ListDictionary();
            listColAndValue.Add(colName, colValue);
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            ormaps.GetEntitys(listColAndValue, 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, Operation operate, object colValue, string[] orderColumns, OrderDirection[] orderDirections)
        {
            ListDictionary listColAndValue = new ListDictionary();
            listColAndValue.Add(colName, colValue);
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            ormaps.GetEntitys(listColAndValue, new Operation[] { operate }, orderColumns, 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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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], colValues[i]);
                }
                ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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, Operation[] operates, object[] colValues, string[] orderColumns, 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], colValues[i]);
                }
                ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
                ormaps.GetEntitys(listColAndValue, operates, orderColumns, orderDirections);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="listColAndValue">实体字段名及对应匹配相等的值</param>
        public roleS(ListDictionary listColAndValue)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
                ormaps.GetEntitys(listColAndValue, operates);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="listColAndValue">实体字段名及对应匹配的值</param>
        /// <param name="operates">实体字段名对应比较操作符</param>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(ListDictionary listColAndValue, Operation[] operates, string[] orderColumns,OrderDirection[] orderDirections)
        {
            if (listColAndValue.Count == operates.Length)
            {
                ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
                ormaps.GetEntitys(listColAndValue, operates, orderColumns, orderDirections);
            }
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="orderColumn">排序字段</param>
        /// <param name="orderDirection">排序方向</param>
        public roleS(string orderColumn,OrderDirection orderDirection)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            ormaps.GetEntitys(new ListDictionary(), new Operation[] { }, new string[] { orderColumn }, new OrderDirection[] { orderDirection });
        }
        /// <summary>
        /// role实体集
        /// </summary>
        /// <param name="orderColumns">排序字段数组</param>
        /// <param name="orderDirections">对应排序方向</param>
        public roleS(string[] orderColumns,OrderDirection[] orderDirections)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            ormaps.GetEntitys(new ListDictionary(), new Operation[] { }, orderColumns, 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, Operation[] operates, string[] orderColumns,OrderDirection[] orderDirections)
        {
            if (listColAndValue.Count == operates.Length)
            {
                ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
                ormaps.GetEntitys(dbCore, listColAndValue, operates, orderColumns, 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, string[] colNames, Operation[] operates, object[] colValues, string[] orderColumns,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], colValues[i]);
                }
                ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
                ormaps.GetEntitys(dbCore, listColAndValue, operates, orderColumns, 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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.Save();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值,若有与主键字段记录相同的就更新,没有就插入,保存全部字段
        /// </summary>
        /// <returns>受影响的行数</returns>
        public int SaveAll()
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.SaveAll();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息 比较实体前后的值,若有与主键字段记录相同的就更新,没有就插入,保存全部字段
        /// 其中若与实体属性字段初始值相同则置该字段为空
        /// </summary>
        /// <returns>受影响的行数</returns>
        public int SaveEx()
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.SaveEx();
        }
        /// <summary>
        /// 通过实体集中的对象信息映射及主键约束批量删除实体集对应表中的多条数据
        /// </summary>
        /// <returns>执行删除并返回受影响的行数</returns>
        public int Delete()
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.Delete();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 比较实体前后默认的初始值,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsert()
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsert();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 比较实体前后默认的初始值,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <param name="strConditionKey"></param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsert(string strConditionKey)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsert(strConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 比较实体前后默认的初始值,且不插入与实体初始值相同的字段值
        /// </summary>
        /// <param name="arrConditionKey">指定作为Delete依据字段,一个或多个,可以使用对应的EntityColumn属性</param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsert(string[] arrConditionKey)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsert(arrConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertEx()
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsertEx();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <param name="strConditionKey"></param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertEx(string strConditionKey)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsertEx(strConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段,其中若与实体字段初始值相同则置该字段为空
        /// </summary>
        /// <param name="arrConditionKey">指定作为Delete依据字段,一个或多个,可以使用对应的EntityColumn属性</param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertEx(string[] arrConditionKey)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsertEx(arrConditionKey);
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段
        /// </summary>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertAll()
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), this);
            return ormaps.DelInsertAll();
        }
        /// <summary>
        /// 批量保存实体集中的对象信息,先Delete后Insert 插入所有字段
        /// </summary>
        /// <param name="strConditionKey"></param>
        /// <returns>先Delete后Insert并返回受影响的行数</returns>
        public int DelInsertAll(string strConditionKey)
        {
            ORMaps<BaseEntity, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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, roleS> ormaps = new ORMaps<BaseEntity, roleS>(new role(), 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, Encoding encoding, Formatting xmlFormatting)
        {
            string xmlString = this.ToXml_(xmlFormatting);
            File.WriteAllText(filename, xmlString, 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) + ",");
            }
            return "[" + sb.ToString().TrimEnd(new char[] { '\n', '\r', ',' }) + "]";
        }
        /// <summary>
        /// 通过与持久化实体集信息相对应的JSON格式信息实例化到该实体集信息
        /// </summary>
        /// <param name="jsonString">JSON格式的实体集信息</param>
        /// <returns>返回实例化后的实体集信息并与JSON格式文本信息保持一致</returns>
        public roleS FromJSON(string jsonString)
        {
            string[] arrayJson = jsonString.Trim(new char[] { '\n', '\r', ' ' }).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', '\r', ' ' }).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, 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
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

PostgreSQL 代码生成工具选择

项目中需要使用支持PostgreSQL的ORM代码生成工具,搜寻了几个常用工具进行了考察,考察的原则是“支持PostgreSQL、易于使用”,最终选择了EntitysCodeGenerate。考察结果...
  • WuLex
  • WuLex
  • 2016-12-09 13:44
  • 611

软件作品

《VB/C#.Net实体代码生成工具》(EntitysCodeGenerate)【ECG】 博客园下载: http://www.cnblogs.com/lxchutao/archi...
  • chutao
  • chutao
  • 2009-08-31 17:42
  • 5745

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

ORM框架-VB/C#.Net实体代码生成工具(EntitysCodeGenerate)【ECG 4.2】的相关使用

1 引言目前大多数项目或产品都使用关系型数据库实现业务数据的存储,这样在开发过程中,常常有一些业务逻辑需要直接用写SQL语句实现,但这样开发的结果是:遍地布满SQL语句。这些藕合较高的SQL语句给系统...
  • chutao
  • chutao
  • 2010-12-17 14:14
  • 3706

VB、C#.Net实体代码生成工具(EntitysCodeGenerate)【ECG】的使用及.NET中的ORM实现

1 引言目前大多数项目或产品都使用关系型数据库实现业务数据的存储,这样在开发过程中,常常有一些业务逻辑需要直接用写SQL语句实现,但这样开发的结果是:遍地布满SQL语句。这些藕合较高的SQL语句给系统...
  • chutao
  • chutao
  • 2010-03-15 13:19
  • 4345

PostgreSQL 代码生成工具选择

考察了动软代码生成器、MyGeneration、Keelkit、Gentle.NET、CodeSmith、EntitysCodeGenerate,基本原则是支持PostgreSQL且易于使用,最终选定...

Mybatis代码生成工具

/** * Author: fuchunyu * Date: 2017/6/28 * Description:mybaits 代码生成工具 */ public class CodeGenera...

代码生成工具

1:CodeSmith   一款人气很旺国外的基于模板的dotnet代码生成器 官方网站:http://www.codesmithtools.com 官方论坛:http://forum...

Abator代码生成工具 - -Eclipse下Ibatis|Mybatis代码生成工具 利器

使用Abator工具来自动生成iBatis代码: 1.安装   1.1.下载安装         首先,下载Abator插件,其Abator下载地址为: http://people.apac...

代码自动生成工具(一)-Csv读表代码自动生成工具

之前提到了自定义的Csv格式的表格读取的一个工具类CsvReader
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)