技术标签： 代码生成器 PostgreSQL Database
项目中需要使用支持PostgreSQL的ORM代码生成工具，搜寻了几个常用工具进行了考察，考察的原则是“支持PostgreSQL、易于使用”，最终选择了EntitysCodeGenerate。
考察结果如下：
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+选项GentleBusinessObject.cst文件的SourceTable参数时，无法指定PostgreSQL数据源（可能是需要自己按照GentleBusinessObject.cst文件编写对应的配置。Gentle.Framework.Broker对Model进行增删查改。配置上比较复杂，CodeSmith一次只能生成一个数据表，用起来不太方便。/******************************************
* 模块名称：实体 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
}
}
一、Python环境的安装1. 下载Python访问python官网: https://www.python.org/点击downloads按钮,在下拉框中选择系统类型(windows/Mac OS/Linux等)选择下载最新版本的Python2. 安装Python双击下载好的Python安装包勾选左下角 Add Python 3.7 to PATH 选项，然后选择 Install now 立刻安装Python.默认安装自定义安装安装完成3. 测试是
[Jarvis OJ - PWN]——[XMAN]level0题目地址：https://www.jarvisoj.com/challenges题目：checksec看看，64位，开启了NX保护IDA,发现了我们的system函数，里面的参数也是我们想要的找到callsystem函数的地址 0x400596 ，或者 system函数开始压参的地址0x40059A都可以作为返回地址。exploit:from pwn import *p = remote("pwn2.jarviso
莫烦python的强化学习教程中tabular Q-learning小例子是一个一维的空间，原文链接https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/2-1-general-rl/，本文将其改进为二维空间，代码如下.# -*- coding: utf-8 -*-"""Created...
一些说明、参阅https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/1_command_line_reinforcement_learning/treasure_on_right.pyhttps://github.com/simoninithomas/De...
2022 Bengurion university Deep Reinforcement learning course conclusion.
实现高级驾驶服务的需求增加，需要车与车之间传递安全消息，传递信息需要占用频谱资源，频谱资源是有限的，并不是所有波长的信号都可以用来进行信号传输。频谱共享使车与车通信（V2V，vehicle-to-vehicle）共享原来的车与基础设施通信（V2I，vehicle-to-infrastructure）的频谱资源进行通信。从而达到合理的进行资源利用
文章目录输入输出1，输入字符串相关算法相关输入输出1，输入获取输入的参数，可以用readline()函数，多个输入参数可以通过多次readline()函数进行读取，比如输入：12abc以上两个参数可以通过以下代码读取：let param1 = readline() // 读取 12let param2 = readline() // 读取 abc当获取字符串相关...
将数据“写入/输出”到文件中//看这个例子一定要举一反三，凡是要将数据输出到文件（写文件）都可这样处理#include //处理文件要包括头文件fstream#include#include //调用exit(1)需要包含cstdlibusing namespace std;int main( ){ int a; //打开文件，要使用文件必须正确打开，对输
ユキノ / 雪乃
疯狂Java学习笔记（68）-----------synchronizedJava并发编程：synchronized Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前...
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。Python 实现斐波那契数列代码如下：实现一： 1 def fibonacci(): 2 num = input("Please input your number\n") 3 i,a,b= 0,0,...
最近接到一个需求，对日志上传的pod进行流量限制。# 前期准备k8s一份calico装好# k8s配置由于默认情况下calico并没有启用流量限制的功能，所以需要在calico的配置文件里面启用一下。在每个节点的/etc/cni/net.d/10-calico.conflist 文件中加入bandwidth的支持。这一步最好在安装calico的时候做了，就不用每个节点都配置一遍。期待calico把...