Trace.ORM.Service、Trace.ORM.Data OR映射数据库访问中间件介绍

这个中间件的编写前提，是从大量的数据库访问操作SQL中解放出来，将开发者的业务点，引入到纯粹的业务层面。

中间件参考了Hibernate和早期一套用过的框架的一些想法观点，更多的想法是做了变体处理，以增加更高的灵活性和易用性。

此处中间件，分两个接口，一个为查询接口，一个为实体映射操作接口，其中的查询接口，主要是应对，很多的面向多表查询，笛卡尔积查询，或聚合查询等条件，因为这些查询，太过于灵活和独立，很难通过后期SQL自动生成，来生成。实体映射操作接口，则是对数据表的真实实体映射，可以实现完全的避免SQL操作。

中间件的某一个调用方法，都提供了注入回调函数，可以在外部观察到中间件内部的SQL生成或处理结果。

中间件支持不同的连接方式，同一数据库访问，支持短连接、长连接和面向表访问的长连接三种连接方式，根据不同的应用场合，可以有效的降低连接池的压力。

所有的事务，设计为采用外部操作系统级事务接口，所以内部的数据库事务，全部不启用，也就是，如果不结合外部的事务中间件，此处中间件将无事务环境可用。

因为采用事务环境注入，因此所有的事务注入点，采用Attribute拦截和编织进入事务范围嵌套。所有实现部分要求方法体为Virtual和Public，便于事务中间件的横向拦截和注入。

实体Entity、属性Property、列Column等概念，参考了Hibernate中的成熟概念，用于对对象与关系数据库之间的映射描述。所有描述信息支持三种类型，分别为元数据描述（声明到代码的Attribute上）、配置文件描述、数据库读取描述，通过配置开关，动态选择。

所有的面向业务层的属性和对象，都与具体的数据库无关，比如SqlParamter、OracleParameter，统一被替换为Parameter，以便达到与数据访问层的无关性。

支持所有的查询分页，而不需要对查询单独编写复杂的分页条件，依赖的是分页对象根据不同的数据库实现，在底层动态拼成分页SQL。

/// <summary>
/// 实体数据OR映射服务接口
/// </summary>
/// <typeparam name="T">实体类</typeparam>
public interface IEntityService<T>
where T : Trace.Common.Data.TraceData
{
/// <summary>
/// 设置Map配置映射
/// </summary>
/// <param name="classMapDataSource">Map配置</param>
void SetClassMapDataSource(ClassMapDataSource classMapDataSource);
/// <summary>
/// 设置数据源
/// </summary>
/// <param name="dataSource">数据源信息</param>
void SetDataSource(DataSource dataSource);
/// <summary>
/// 根据Where查询数量
/// </summary>
/// <param name="where">where查询条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
int Count(Where where);
/// <summary>
/// 根据Where查询数量
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="onCountCommandCallBack">构建命令回调</param>
/// <param name="onCountParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
int Count(Where where, EntityCountCommandCallBack<T> onCountCommandCallBack, EnityCountParameterCallBack onCountParameterCallBack);
/// <summary>
/// 直接删除实体数据，传入的对象强制更改为Deleted状态
/// </summary>
/// <param name="data">删除的实体对象</param>
/// <param name="onDeleteCommandCallBack">删除命令构建回调</param>
/// <param name="onDeleteParamterCallBack">删除参数构建回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Delete(T data, EntitySaveCommandCallBack<T> onDeleteCommandCallBack, EntitySaveParameterCallBack<T> onDeleteParamterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 直接删除实体数据，传入的对象强制更改为Deleted状态
/// </summary>
/// <param name="data">删除的实体对象</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Delete(T data, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 根据删除条件，执行批量删除
/// </summary>
/// <param name="where">删除条件</param>
/// <param name="onDeleteWhereCommandCallBack">删除命令回调</param>
/// <param name="onDeleteWhereParameterCallBack">删除参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
int Delete(Where where, EntityDeleteWhereCommandCallBack onDeleteWhereCommandCallBack, EntityDeleteWhereParameterCallBack onDeleteWhereParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 根据删除条件，执行批量删除
/// </summary>
/// <param name="where">删除条件</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
int Delete(Where where, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量直接删除
/// </summary>
/// <param name="list">删除的数据集合</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> DeleteCollection(Trace.Common.Data.DataCollection<T> list, EntitySaveCommandCallBack<T> onDeleteCommandCallBack, EntitySaveParameterCallBack<T> onDeleteParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量直接删除
/// </summary>
/// <param name="list">更新的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> DeleteCollection(Trace.Common.Data.DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 执行命令语句
/// </summary>
/// <param name="commandText">SQL命令</param>
/// <param name="parameters">参数集合</param>
/// <param name="onExcuteParameterCallBack">参数构建回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns>
/// 返回执行结果
/// </returns>
[TransactionScopeOption(ScopeOption.Required)]
int ExcuteCommand(string commandText, Parameters parameters, EntityExcuteParameterCallBack onExcuteParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 执行命令语句
/// </summary>
/// <param name="commandText">SQL命令</param>
/// <param name="parameters">参数集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns>
/// 返回执行结果
/// </returns>
[TransactionScopeOption(ScopeOption.Required)]
int ExcuteCommand(string commandText, Parameters parameters, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 实体数据是否存在
/// </summary>
/// <param name="data">查询的实体对象</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
bool Exist(T data);
/// <summary>
/// 实体数据是否存在
/// </summary>
/// <param name="data">查询的实体对象</param>
/// <param name="onExistCommandCallBack">SQL命令处理回调</param>
/// <param name="onExistParameterCallBack">SQL参数处理回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
bool Exist(T data, EntityExistCommandCallBack<T> onExistCommandCallBack, EntityExistParameterCallBack<T> onExistParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, MaxRecords rowNumbers);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, MaxRecords rowNumbers, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, Order order);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, Order order, MaxRecords rowNumbers);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, Order order, MaxRecords rowNumbers, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, Order order, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(Where where, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack);
/// <summary>
/// 根据查询SQL语句，查询对应的数据集合
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parameters">查询参数集合</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> FindByCommand(SQLCommandText commandText, Parameters parameters);
/// <summary>
/// 根据查询SQL语句，查询对应的数据集合
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parameters">查询参数集合</param>
/// <param name="parameterCallBack">参数回调处理</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> FindByCommand(SQLCommandText commandText, Parameters parameters, EntityFindParameterCallBack onFindParameterCallBack);
/// <summary>
/// 直接插入实体数据，传入的对象强制更改为Created状态
/// </summary>
/// <param name="data">插入的实体数据</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Insert(T data, EntitySaveCommandCallBack<T> onInsertCommandCallBack, EntitySaveParameterCallBack<T> onInsertParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 直接插入实体数据，传入的对象强制更改为Created状态
/// </summary>
/// <param name="data">插入的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Insert(T data, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量直接插入
/// </summary>
/// <param name="list">插入的数据集合</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> InsertCollection(Trace.Common.Data.DataCollection<T> list, EntitySaveCommandCallBack<T> onInsertCommandCallBack, EntitySaveParameterCallBack<T> onInsertParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量直接插入
/// </summary>
/// <param name="list">插入的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> InsertCollection(Trace.Common.Data.DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 保存数据
/// </summary>
/// <param name="data">保存的实体数据</param>
/// <param name="onSaveCommandCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Save(T data, EntitySaveCommandCallBack<T> onSaveCommandCallBack, EntitySaveParameterCallBack<T> onSaveParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 保存数据
/// </summary>
/// <param name="data">保存的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Save(T data, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量保存
/// </summary>
/// <param name="list">保存的数据集合</param>
/// <param name="onSaveCommandCallBack">构建命令回调</param>
/// <param name="onSaveParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> SaveCollection(Trace.Common.Data.DataCollection<T> list, EntitySaveCommandCallBack<T> onSaveCommandCallBack, EntitySaveParameterCallBack<T> onSaveParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量保存
/// </summary>
/// <param name="list">保存的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> SaveCollection(Trace.Common.Data.DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 直接更新实体数据，传入的对象强制更改为Modified状态
/// </summary>
/// <param name="data">更新的实体数据</param>
/// <param name="onUpdateCommandCallBack">构建命令回调</param>
/// <param name="onUpdateParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Update(T data, EntitySaveCommandCallBack<T> onUpdateCommandCallBack, EntitySaveParameterCallBack<T> onUpdateParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 直接更新实体数据，传入的对象强制更改为Modified状态
/// </summary>
/// <param name="data">更新的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Update(T data, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 根据更新集合，更新某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="where">更新条件</param>
/// <param name="onUpdatePropertysCommandCallBack">构建命令回调</param>
/// <param name="onUpdatePropertysParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
int Update(UpdatePropertys update, Where where, EntityUpdatePropertysCommandCallBack onUpdatePropertysCommandCallBack, EntityUpdatePropertysWhereParameterCallBack onUpdatePropertysParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 根据更新集合，更新某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="where">更新条件</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
int Update(UpdatePropertys update, Where where, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 根据更新集合，更新某一个对象的某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="data">更新对象</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Update(UpdatePropertys update, T data, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 根据更新集合，更新某一个对象的某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="data">更新对象</param>
/// <param name="onUpdatePropertysCommandCallBack">更新命令</param>
/// <param name="onUpdatePropertysParameterCallBack">更新的参数对象</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
T Update(UpdatePropertys update, T data, EntityUpdateDataPropertysCommandCallBack<T> onUpdatePropertysCommandCallBack, EntityUpdatePropertysParameterCallBack<T> onUpdatePropertysParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量直接更新
/// </summary>
/// <param name="list">更新的数据集合</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> UpdateCollection(Trace.Common.Data.DataCollection<T> list, EntitySaveCommandCallBack<T> onUpdateCommandCallBack, EntitySaveParameterCallBack<T> onUpdateParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// 批量直接更新
/// </summary>
/// <param name="list">更新的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
Trace.Common.Data.DataCollection<T> UpdateCollection(Trace.Common.Data.DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect);
/// <summary>
/// Reader转化为实体数据前回调
/// 如果在事件回调函数中手工转换了，则系统不再进行自动转换
/// </summary>
event DbDataReaderToEntityBegin<T> OnReaderToEntityBegin;
/// <summary>
/// Reader转化为实体数据完毕回调
/// 可以更改自动转换完毕的数据
/// </summary>
event DbDataReaderToEntityEnd<T> OnReaderToEntityEnd;
}

上述为实体访问接口，该接口主要的面向于数据的写入操作，和部分的面向实体映射表的查询操作，八成的业务逻辑，在服务治理层面，都是面向独立的原子性服务，此处的服务调用，也是面向了原子性的服务，通过外部的事务环境和全局连接开关，可以把不同的原子性服务，组合成更复杂的业务场景。

以Oracle数据库访问实现为例，下面是面向Oracle的一个数据库访问实体基类，所有的方法，必须为Publice和Virtual,便于事务中间件对方法的拦截和注入，以便重写方法，嵌套事务范围。

/// <summary>
/// Oracle数据库操作
/// Oracle提供的.net数据库访问API
/// </summary>
/// <typeparam name="T"></typeparam>
public class OracleEntityService<T> : IEntityService<T>  where T : TraceData
{
private ClassMapDataSource classMapDataSource;
/// <summary>
/// 获取配置映射
/// </summary>
/// <returns></returns>
protected ClassMapDataSource GetClassMapDataSource()
{
if (classMapDataSource != null)
{
return classMapDataSource;
}
ClassMapDataSource tempClassMapDataSource = ClassMapDataSourceHelper.Load<T>();
if (tempClassMapDataSource == null)
{
throw new Exception("获取实体类到数据库的映射配置失败");
}

classMapDataSource = tempClassMapDataSource;
return classMapDataSource;
}
/// <summary>
/// 数据源
/// </summary>
private DataSource dataSource;
/// <summary>
/// 获取数据源
/// </summary>
/// <returns></returns>
protected DataSource GetDataSource()
{
if (dataSource != null)
{
return dataSource;
}
ClassMapDataSource tempClassMapDataSource = GetClassMapDataSource();
DataSource tempDataSource = DataSourceHelper.Load(tempClassMapDataSource);
if (tempDataSource == null)
{
throw new Exception("获取数据源配置失败");
}
if (tempDataSource.DataSourceType != DataSourceType.Oracle)
{
throw new Exception("当前数据源连接字符串不是有效的Oracle连接字符串");
}
dataSource = tempDataSource;
return dataSource;
}
/// <summary>
/// 数据转化处理实体
/// </summary>
private Entity entity = null;
/// <summary>
/// 获取实体映射
/// </summary>
/// <returns></returns>
protected Entity getEntity()
{
if (entity == null)
{
ClassMapDataSource tempClassMapDataSource = GetClassMapDataSource();
this.entity = OracleEntityHelper.Load<T>(tempClassMapDataSource.EntityLoadType);
}
if (entity == null)
{
throw new Exception("获取实体对应的数据库配置映射失败");
}
return entity;
}
#region 实体的命令和参数构建
/// <summary>
/// 实体查询语句
/// </summary>
private string selectCommandText = null;
/// <summary>
/// 实体插入语句
/// </summary>
private string insertCommandText = null;
/// <summary>
/// 实体更新语句
/// </summary>
private string updateCommandText = null;
/// <summary>
/// 实体删除语句
/// </summary>
private string deleteCommandText = null;
/// <summary>
/// 实体对应的Select SQL语句
/// </summary>
/// <returns></returns>
protected virtual string EntitySelectCommand()
{
if (string.IsNullOrEmpty(this.selectCommandText))
{
Entity tempEntity = getEntity();
this.selectCommandText = OracleCommandHelper.CreateEntitySelectCommand(tempEntity);
}
return this.selectCommandText;
}
/// <summary>
/// 实体Select对应的参数赋值
/// </summary>
/// <param name="item">数据实体</param>
/// <returns></returns>
protected virtual OracleParameter[] EntitySelectParameters(T item)
{
Entity tempEntity = getEntity();
return OracleParameterHelper.CreateEntitySelectParameter<T>(tempEntity, item);
}
/// <summary>
/// 实体对应的Insert SQL语句
/// </summary>
/// <returns></returns>
protected virtual string EntityInsertCommand()
{
if (string.IsNullOrEmpty(this.insertCommandText))
{
Entity tempEntity = getEntity();
this.insertCommandText = OracleCommandHelper.CreateEntityInsertCommand(tempEntity);
}
return this.insertCommandText;
}
/// <summary>
/// 实体Insert对应的参数赋值
/// </summary>
/// <param name="item">数据实体</param>
/// <returns></returns>
protected virtual OracleParameter[] EntityInsertParameters(T item)
{
Entity tempEntity = getEntity();
return OracleParameterHelper.CreateEntityInsertParameter<T>(tempEntity, item);
}
/// <summary>
/// 实体对应的Update SQL语句
/// </summary>
/// <returns></returns>
protected virtual string EntityUpdateCommand()
{
if (string.IsNullOrEmpty(this.updateCommandText))
{
Entity tempEntity = getEntity();
this.updateCommandText = OracleCommandHelper.CreateEntityUpdateCommand(tempEntity);
}
return this.updateCommandText;
}
/// <summary>
/// 实体Update对应的参数赋值
/// </summary>
/// <param name="item">数据实体</param>
/// <returns></returns>
protected virtual OracleParameter[] EntityUpdateParameters(T item)
{
Entity tempEntity = getEntity();
return OracleParameterHelper.CreateEntityUpdateParameter<T>(tempEntity, item);
}
/// <summary>
/// 实体对应的Delete SQL语句
/// </summary>
/// <returns></returns>
protected virtual string EntityDeleteCommand()
{
if (string.IsNullOrEmpty(this.deleteCommandText))
{
Entity tempEntity = getEntity();
this.deleteCommandText = OracleCommandHelper.CreateEntityDeleteCommand(tempEntity);
}
return this.deleteCommandText;
}
/// <summary>
/// 实体Delete对应的参数赋值
/// </summary>
/// <param name="item">数据实体</param>
/// <returns></returns>
protected virtual OracleParameter[] EntityDeleteParameters(T item)
{
Entity tempEntity = getEntity();
return OracleParameterHelper.CreateEntityDeleteParameter<T>(tempEntity, item);
}
#endregion
#region Save 根据对象状态保存
/// <summary>
/// 保存数据
/// </summary>
/// <param name="data">保存的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Save(T data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.Save(data, null, null, connectionType);
}
/// <summary>
/// 保存数据
/// </summary>
/// <param name="data">保存的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <param name="onSaveCommandCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Save(T data, EntitySaveCommandCallBack<T> onSaveCommandCallBack, EntitySaveParameterCallBack<T> onSaveParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
OracleConnection connection = null;
try
{
string commandText = null;
OracleParameter[] parameters = null;
if (data.DataState == DataState.Created)
{
commandText = this.EntityInsertCommand();
parameters = this.EntityInsertParameters(data);
}
else if (data.DataState == DataState.Modified)
{
commandText = this.EntityUpdateCommand();
parameters = this.EntityUpdateParameters(data);
}
else if (data.DataState == DataState.Deleted)
{
commandText = this.EntityDeleteCommand();
parameters = this.EntityDeleteParameters(data);
}
else if (data.DataState == DataState.Unchanged)
{
return data;
}
if (onSaveCommandCallBack != null)
{
commandText = onSaveCommandCallBack(data, commandText, data.DataState, DataSourceType.Oracle);
}
if (onSaveParameterCallBack != null)
{
parameters = (OracleParameter[])onSaveParameterCallBack(data, parameters, data.DataState, DataSourceType.Oracle);
}
connection = (OracleConnection)this.OpenConnection(connectionType);
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.CommandText = commandText;
command.Parameters.AddRange(parameters);
command.ExecuteNonQuery();
if (data.DataState != DataState.Deleted)
{
data.SetDataState(DataState.Unchanged);
}
return data;
}
catch (Exception ex)
{
throw ex;
}
finally
{
this.CloseConnection(connectionType, connection);
}
}
/// <summary>
/// 批量保存
/// </summary>
/// <param name="list">保存的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> SaveCollection(DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.SaveCollection(list, null, null, connectionType);
}
/// <summary>
/// 批量保存
/// </summary>
/// <param name="list">保存的数据集合</param>
/// <param name="onSaveCommandCallBack">构建命令回调</param>
/// <param name="onSaveParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> SaveCollection(DataCollection<T> list, EntitySaveCommandCallBack<T> onSaveCommandCallBack, EntitySaveParameterCallBack<T> onSaveParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
if (connectionType == ConnectionType.EveryConncet)
{
connectionType = ConnectionType.EntityConnect;
}
DataCollection<T> deleteList = new DataCollection<T>();
for (int i = 0; i < list.Count; i++)
{
T item = list[i];
this.Save(item, onSaveCommandCallBack, onSaveParameterCallBack, connectionType);
if (item.DataState == DataState.Deleted)
{
deleteList.Add(item);
}
}
for (int i = 0; i < deleteList.Count; i++)
{
list.Remove(deleteList[i]);
}
for (int i = 0; i < list.Count; i++)
{
list[i].SetDataState(DataState.Unchanged);
}
return list;
}
#endregion
#region 数据是否存在查询
/// <summary>
/// 实体数据是否存在
/// </summary>
/// <param name="data">查询的实体对象</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual bool Exist(T data)
{
return this.Exist(data, null, null);
}
/// <summary>
/// 实体数据是否存在
/// </summary>
/// <param name="data">查询的实体对象</param>
/// <param name="onExistCommandCallBack">SQL命令处理回调</param>
/// <param name="onExistParameterCallBack">SQL参数处理回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual bool Exist(T data, EntityExistCommandCallBack<T> onExistCommandCallBack, EntityExistParameterCallBack<T> onExistParameterCallBack)
{
OracleConnection connection = null;
try
{
string commandText = this.EntitySelectCommand();
if (onExistCommandCallBack != null)
{
commandText = onExistCommandCallBack(data, commandText, DataSourceType.Oracle);
}
OracleParameter[] parameters = this.EntitySelectParameters(data);
if (onExistParameterCallBack != null)
{
parameters = (OracleParameter[])onExistParameterCallBack(data, parameters, DataSourceType.Oracle);
}
DataSource tempDataSource = GetDataSource();
connection = new OracleConnection(tempDataSource.ConnectString);
connection.Open();
OracleCommand command = connection.CreateCommand();
command.CommandText = commandText;
command.Parameters.Clear();
command.Parameters.AddRange(parameters);
object item = command.ExecuteScalar();
if (item != null)
{
return true;
}
return false;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (connection != null)
{
connection.Close();
}
}
}
#endregion
#region Insert 处理
/// <summary>
/// 直接插入实体数据，传入的对象强制更改为Created状态
/// </summary>
/// <param name="data">插入的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Insert(T data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
data.DataState = DataState.Created;
return this.Save(data, connectionType);
}
/// <summary>
/// 直接插入实体数据，传入的对象强制更改为Created状态
/// </summary>
/// <param name="data">插入的实体数据</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Insert(T data, EntitySaveCommandCallBack<T> onInsertCommandCallBack, EntitySaveParameterCallBack<T> onInsertParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
data.DataState = DataState.Created;
return this.Save(data, onInsertCommandCallBack, onInsertParameterCallBack, connectionType);
}
/// <summary>
/// 批量直接插入
/// </summary>
/// <param name="list">插入的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> InsertCollection(DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.InsertCollection(list, null, null, connectionType);
}
/// <summary>
/// 批量直接插入
/// </summary>
/// <param name="list">插入的数据集合</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> InsertCollection(DataCollection<T> list, EntitySaveCommandCallBack<T> onInsertCommandCallBack, EntitySaveParameterCallBack<T> onInsertParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
if (connectionType == ConnectionType.EveryConncet)
{
connectionType = ConnectionType.EntityConnect;
}
for (int i = 0; i < list.Count; i++)
{
T item = list[i];
item.DataState = DataState.Created;
this.Save(item, onInsertCommandCallBack, onInsertParameterCallBack, connectionType);
}
for (int i = 0; i < list.Count; i++)
{
list[i].SetDataState(DataState.Unchanged);
}
return list;
}
#endregion
#region Update 处理
/// <summary>
/// 直接更新实体数据，传入的对象强制更改为Modified状态
/// </summary>
/// <param name="data">更新的实体数据</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Update(T data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
data.DataState = DataState.Modified;
return this.Save(data,connectionType);
}
/// <summary>
/// 直接更新实体数据，传入的对象强制更改为Modified状态
/// </summary>
/// <param name="data">更新的实体数据</param>
/// <param name="onUpdateCommandCallBack">构建命令回调</param>
/// <param name="onUpdateParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Update(T data, EntitySaveCommandCallBack<T> onUpdateCommandCallBack, EntitySaveParameterCallBack<T> onUpdateParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
data.DataState = DataState.Modified;
return this.Save(data, onUpdateCommandCallBack,onUpdateParameterCallBack, connectionType);
}
/// <summary>
/// 根据更新集合，更新某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="where">更新条件</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual int Update(UpdatePropertys update,Where where, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.Update(update, where, null, null, connectionType);
}
/// <summary>
/// 根据更新集合，更新某一个对象的某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="data">更新对象</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Update(UpdatePropertys update, T data,ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.Update(update, data, null, null, connectionType);
}
/// <summary>
/// 根据更新集合，更新某一个对象的某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="data">更新对象</param>
/// <param name="onUpdatePropertysCommandCallBack">更新命令</param>
/// <param name="onUpdatePropertysParameterCallBack">更新的参数对象</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Update(UpdatePropertys update, T data, EntityUpdateDataPropertysCommandCallBack<T> onUpdatePropertysCommandCallBack, EntityUpdatePropertysParameterCallBack<T> onUpdatePropertysParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
OracleConnection connection = null;
try
{
Entity tempEntity = getEntity();
string commandText = OracleCommandHelper.CreateEntityUpdatePropertysCommandEntity(tempEntity, update);
if (onUpdatePropertysCommandCallBack != null)
{
commandText = onUpdatePropertysCommandCallBack(update,data, commandText, DataSourceType.Oracle);
}
OracleParameter[] parameters = OracleParameterHelper.CreateEntityUpdatePropertysParameterEntity<T>(tempEntity, update,data);
if (onUpdatePropertysParameterCallBack != null)
{
parameters = (OracleParameter[])onUpdatePropertysParameterCallBack(update, data, parameters, DataSourceType.Oracle);
}
connection = (OracleConnection)this.OpenConnection(connectionType);
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.Parameters.AddRange(parameters);
command.CommandText = commandText;
int count=command.ExecuteNonQuery();
if (count <= 0)
{
throw new Exception("更新失败，数据库中对应的实体数据已删除");
}
for (int i = 0; i < update.UpdateItemList.Count; i++)
{
UpdateProperty property = update.UpdateItemList[i];
EntityProperty entityProperty = tempEntity.FindEntityPropertyByPropertyName(property.PropertyName);
if (entityProperty == null)
{
throw new Exception(string.Format("更新条件中的属性{0}对应的实体数据属性不存在", property.PropertyName));
}
entityProperty.PropertyInfo.SetValue(data,property.DataValue, null);
}
if (data.DataState != DataState.Unchanged)
{
data.DataState = DataState.Unchanged;
}
return data;
}
catch (Exception ex)
{
throw ex;
}
finally
{
this.CloseConnection(connectionType, connection);
}
}
/// <summary>
/// 根据更新集合，更新某些字段的内容
/// </summary>
/// <param name="update">更新集合内容</param>
/// <param name="where">更新条件</param>
/// <param name="onUpdatePropertysCommandCallBack">构建命令回调</param>
/// <param name="onUpdatePropertysParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual int Update(UpdatePropertys update, Where where, EntityUpdatePropertysCommandCallBack onUpdatePropertysCommandCallBack, EntityUpdatePropertysWhereParameterCallBack onUpdatePropertysParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
OracleConnection connection = null;
try
{
Entity tempEntity = getEntity();
string commandText = OracleCommandHelper.CreateEntityUpdatePropertysCommandWhere(tempEntity, update, where);
if (onUpdatePropertysCommandCallBack != null)
{
commandText = onUpdatePropertysCommandCallBack(update, where, commandText, DataSourceType.Oracle);
}
OracleParameter[] parameters = OracleParameterHelper.CreateEntityUpdatePropertysParameterWhere(tempEntity, where, update);
if (onUpdatePropertysParameterCallBack != null)
{
parameters = (OracleParameter[])onUpdatePropertysParameterCallBack(update, where , parameters, DataSourceType.Oracle);
}
connection = (OracleConnection)this.OpenConnection(connectionType);
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.Parameters.AddRange(parameters);
command.CommandText = commandText;
return command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
this.CloseConnection(connectionType, connection);
}
}
/// <summary>
/// 批量直接更新
/// </summary>
/// <param name="list">更新的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> UpdateCollection(DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.UpdateCollection(list, null, null, connectionType);
}
/// <summary>
/// 批量直接更新
/// </summary>
/// <param name="list">更新的数据集合</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> UpdateCollection(DataCollection<T> list, EntitySaveCommandCallBack<T> onUpdateCommandCallBack, EntitySaveParameterCallBack<T> onUpdateParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
if (connectionType == ConnectionType.EveryConncet)
{
connectionType = ConnectionType.EntityConnect;
}
for (int i = 0; i < list.Count; i++)
{
T item = list[i];
item.DataState = DataState.Modified;
this.Save(item, onUpdateCommandCallBack, onUpdateParameterCallBack, connectionType);
}
for (int i = 0; i < list.Count; i++)
{
list[i].SetDataState(DataState.Unchanged);
}
return list;
}
#endregion
#region Delete 处理
/// <summary>
/// 直接删除实体数据，传入的对象强制更改为Deleted状态
/// </summary>
/// <param name="data">删除的实体对象</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Delete(T data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
data.DataState = DataState.Deleted;
return this.Save(data);
}
/// <summary>
/// 直接删除实体数据，传入的对象强制更改为Deleted状态
/// </summary>
/// <param name="data">删除的实体对象</param>
/// <param name="onDeleteCommandCallBack">删除命令构建回调</param>
/// <param name="onDeleteParamterCallBack">删除参数构建回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual T Delete(T data,EntitySaveCommandCallBack<T> onDeleteCommandCallBack,EntitySaveParameterCallBack<T> onDeleteParamterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
data.DataState = DataState.Deleted;
return this.Save(data,onDeleteCommandCallBack,onDeleteParamterCallBack);
}
/// <summary>
/// 根据删除条件，执行批量删除
/// </summary>
/// <param name="where">删除条件</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual int Delete(Where where, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.Delete(where, null, null, connectionType);
}
/// <summary>
/// 根据删除条件，执行批量删除
/// </summary>
/// <param name="where">删除条件</param>
/// <param name="onDeleteWhereCommandCallBack">删除命令回调</param>
/// <param name="onDeleteWhereParameterCallBack">删除参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual int Delete(Where where, EntityDeleteWhereCommandCallBack onDeleteWhereCommandCallBack, EntityDeleteWhereParameterCallBack onDeleteWhereParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
OracleConnection connection = null;
try
{
Entity tempEntity = getEntity();
string commandText = OracleCommandHelper.CreateEntityDeleteCommandWhere(tempEntity, where);
if(onDeleteWhereCommandCallBack!=null)
{
commandText=onDeleteWhereCommandCallBack(where,commandText,DataSourceType.Oracle);
}
OracleParameter[] parameters = OracleParameterHelper.CreateEntityDeleteParameterWhere(tempEntity, where);
if (onDeleteWhereParameterCallBack != null)
{
parameters = (OracleParameter[])onDeleteWhereParameterCallBack(where, parameters, DataSourceType.Oracle);
}
connection = (OracleConnection)this.OpenConnection(connectionType);
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.Parameters.AddRange(parameters);
command.CommandText = commandText;
return command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
this.CloseConnection(connectionType, connection);
}
}
/// <summary>
/// 批量直接删除
/// </summary>
/// <param name="list">更新的数据集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> DeleteCollection(DataCollection<T> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.DeleteCollection(list, null, null, connectionType);
}
/// <summary>
/// 批量直接删除
/// </summary>
/// <param name="list">删除的数据集合</param>
/// <param name="onInsertCommandCallBack">构建命令回调</param>
/// <param name="onInsertParameterCallBack">参数回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual DataCollection<T> DeleteCollection(DataCollection<T> list, EntitySaveCommandCallBack<T> onDeleteCommandCallBack, EntitySaveParameterCallBack<T> onDeleteParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
if (connectionType == ConnectionType.EveryConncet)
{
connectionType = ConnectionType.EntityConnect;
}
for (int i = 0; i < list.Count; i++)
{
T item = list[i];
item.DataState = DataState.Deleted;
this.Save(item, onDeleteCommandCallBack, onDeleteParameterCallBack, connectionType);
}
for (int i = 0; i < list.Count; i++)
{
list[i].SetDataState(DataState.Unchanged);
}
return list;
}
#endregion
#region Find查询
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where)
{
return this.Find(where, new MaxRecords(-1));
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
return this.Find(where, new MaxRecords(-1), onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, MaxRecords rowNumbers)
{
return this.Find(where, null, rowNumbers, null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, MaxRecords rowNumbers, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
return this.Find(where, null, rowNumbers, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, Order order)
{
return this.Find(where, order, new MaxRecords(-1), null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, Order order, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
return this.Find(where, order, new MaxRecords(-1), onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, Order order, MaxRecords rowNumbers)
{
return this.Find(where, order, rowNumbers, null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(Where where, Order order, MaxRecords rowNumbers, EntityFindCommandCallBack<T> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
OracleConnection connection = null;
DataCollection<T> list = new DataCollection<T>();
try
{
Entity tempEntity = getEntity();
string commandText = OracleCommandHelper.CreateEntitySelectCommandWhere(tempEntity, where, order, rowNumbers);
if (onFindCommandCallBack != null)
{
commandText = onFindCommandCallBack(where, order, rowNumbers , commandText, DataSourceType.Oracle);
}
OracleParameter[] parameters = OracleParameterHelper.CreateEntitySelectParameterWhere(tempEntity, where);
if (onFindParameterCallBack != null)
{
parameters = (OracleParameter[])onFindParameterCallBack(where, order,rowNumbers, parameters, DataSourceType.Oracle);
}
DataSource tempDataSource = GetDataSource();
connection = new OracleConnection(tempDataSource.ConnectString);
connection.Open();
OracleCommand command = connection.CreateCommand();
command.CommandText = commandText;
command.Parameters.Clear();
command.Parameters.AddRange(parameters);
OracleDataReader reader = command.ExecuteReader();
while (reader.Read() == true)
{
T data = this.ChangeToData(reader);
data.SetDataState(DataState.Unchanged);
list.Add(data);
}
return list;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (connection != null)
{
connection.Close();
}
}
}
#endregion
#region 查询数量
/// <summary>
/// 根据Where查询数量
/// </summary>
/// <param name="where">where查询条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual int Count(Where where)
{
return this.Count(where, null, null);
}
/// <summary>
/// 根据Where查询数量
/// </summary>
/// <param name="where">where查询条件</param>
/// <param name="onCountCommandCallBack">构建命令回调</param>
/// <param name="onCountParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual int Count(Where where, EntityCountCommandCallBack<T> onCountCommandCallBack, EnityCountParameterCallBack onCountParameterCallBack)
{
OracleConnection connection = null;
DataCollection<T> list = new DataCollection<T>();
try
{
Entity tempEntity = getEntity();
string commandText = OracleCommandHelper.CreateCountCommandWhere(tempEntity, where);
if (onCountCommandCallBack != null)
{
commandText = onCountCommandCallBack(where, commandText, DataSourceType.Oracle);
}
OracleParameter[] parameters = OracleParameterHelper.CreateEntitySelectParameterWhere(tempEntity, where);
if (onCountParameterCallBack != null)
{
parameters = (OracleParameter[])onCountParameterCallBack(where, parameters, DataSourceType.Oracle);
}
DataSource tempDataSource = GetDataSource();
connection = new OracleConnection(tempDataSource.ConnectString);
connection.Open();
OracleCommand command = connection.CreateCommand();
command.CommandText = commandText;
command.Parameters.Clear();
command.Parameters.AddRange(parameters);
object count = command.ExecuteScalar();
return (int)(decimal)count;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (connection != null)
{
connection.Close();
}
}
}
#endregion
#region Find Command 查询
/// <summary>
/// 根据查询SQL语句，查询对应的数据集合
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parameters">查询参数集合</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> FindByCommand(SQLCommandText commandText, Parameters parameters)
{
return this.FindByCommand(commandText, parameters, null);
}
/// <summary>
/// 根据查询SQL语句，查询对应的数据集合
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parameters">查询参数集合</param>
/// <param name="onFindParameterCallBack">参数回调处理</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> FindByCommand(SQLCommandText commandText, Parameters parameters, EntityFindParameterCallBack onFindParameterCallBack)
{
OracleConnection connection = null;
DataCollection<T> list = new DataCollection<T>();
try
{
Entity tempEntity = getEntity();
OracleParameter[] oracleParameters = OracleParameterHelper.CreateEntityParameters(tempEntity, parameters);
if (onFindParameterCallBack != null)
{
oracleParameters = (OracleParameter[])onFindParameterCallBack(parameters, oracleParameters, DataSourceType.Oracle);
}
DataSource tempDataSource = GetDataSource();
connection = new OracleConnection(tempDataSource.ConnectString);
connection.Open();
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.Parameters.AddRange(oracleParameters);
command.CommandText = commandText.OracleCommandText;
OracleDataReader reader = command.ExecuteReader();
while (reader.Read() == true)
{
T data = this.ChangeToData(reader);
data.SetDataState(DataState.Unchanged);
list.Add(data);
}
return list;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (connection != null)
{
connection.Close();
}
}
}
#endregion
#region Excute Command 执行
/// <summary>
/// 执行命令语句
/// </summary>
/// <param name="commandText">SQL命令</param>
/// <param name="parameters">参数集合</param>
/// <param name="connectionType">连接类型</param>
/// <returns>
/// 返回执行结果
/// </returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual int ExcuteCommand(string commandText, Parameters parameters, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return this.ExcuteCommand(commandText, parameters, null, connectionType);
}
/// <summary>
/// 执行命令语句
/// </summary>
/// <param name="commandText">SQL命令</param>
/// <param name="parameters">参数集合</param>
/// <param name="onExcuteParameterCallBack">参数构建回调</param>
/// <param name="connectionType">连接类型</param>
/// <returns>
/// 返回执行结果
/// </returns>
[TransactionScopeOption(ScopeOption.Required)]
public virtual int ExcuteCommand(string commandText, Parameters parameters, EntityExcuteParameterCallBack onExcuteParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
OracleConnection connection = null;
try
{
Entity tempEntity = getEntity();
OracleParameter[] oracleParameters = OracleParameterHelper.CreateEntityParameters(tempEntity, parameters);
if (onExcuteParameterCallBack != null)
{
oracleParameters = (OracleParameter[])onExcuteParameterCallBack(parameters, oracleParameters, DataSourceType.Oracle);
}
connection = (OracleConnection)this.OpenConnection(connectionType);
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.Parameters.AddRange(oracleParameters);
command.CommandText = commandText;
return command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
this.CloseConnection(connectionType, connection);
}
}
#endregion
/// <summary>
/// 创建数据实体
/// </summary>
/// <param name="reader">数据读取器</param>
/// <returns>
/// 返回对应读取到的数据实体
/// </returns>
protected T ChangeToData(DbDataReader reader)
{
if (OnReaderToEntityBegin != null)
{
DbDataReaderBeginEventArgs<T> eBegin = new DbDataReaderBeginEventArgs<T>(reader);
OnReaderToEntityBegin(this, eBegin);
if (eBegin.Data != null)
{
if (OnReaderToEntityEnd != null)
{
DbDataReaderEndEventArgs<T> eEnd = new DbDataReaderEndEventArgs<T>(reader, eBegin.Data);
OnReaderToEntityEnd(this, eEnd);
return eEnd.Data;
}
}
}
Entity tempEntity = getEntity();
T data = Activator.CreateInstance<T>();
int count = reader.FieldCount;
for (int i = 0; i < count; i++)
{
if (reader.IsDBNull(i))
{
continue;
}
string columnName = reader.GetName(i);
EntityProperty entityProperty = tempEntity.FindEntityPropertyByColumnName(columnName);
if (entityProperty == null)
{
throw new Exception(string.Format("列{0}映射的实体数据属性不存在", columnName));
}
entityProperty.PropertyInfo.SetValue(data, reader[columnName], null);
}
if (OnReaderToEntityEnd != null)
{
DbDataReaderEndEventArgs<T> eEnd = new DbDataReaderEndEventArgs<T>(reader, data);
OnReaderToEntityEnd(this, eEnd);
return eEnd.Data;
}
return data;
}
/// <summary>
/// 获取打开连接
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="requestID">请求对象ID</param>
/// <returns></returns>
private IDbConnection OpenConnection(ConnectionType connectionType)
{
DataSource tempDataSource = GetDataSource();
if (connectionType == ConnectionType.EveryConncet)
{

IDbConnection tempDBConnection = new OracleConnection(tempDataSource.ConnectString);
tempDBConnection.Open();
return tempDBConnection;
}
DBConnectionPool pool = DBConnectionPoolHelper.DBConnectionPool;
if (pool == null)
{
pool = new DBConnectionPool();
DBConnectionPoolHelper.DBConnectionPool = pool;
}
IDbConnection dbConnection = pool.Get(connectionType, tempDataSource.ConnectString, typeof(T).AssemblyQualifiedName);
if (dbConnection == null)
{
dbConnection = new OracleConnection(tempDataSource.ConnectString);
dbConnection.Open();
pool.Create(dbConnection, connectionType, tempDataSource.ConnectString, typeof(T).AssemblyQualifiedName);
}
return dbConnection;
}
/// <summary>
/// 关闭连接
/// 短连接直接关闭，长连接，利用事务环境进行关闭
/// </summary>
/// <param name="connectionType">连接类型</param>
/// <param name="dbConnection">连接</param>
private void CloseConnection(ConnectionType connectionType, IDbConnection dbConnection)
{
if (connectionType == ConnectionType.EveryConncet)
{
if (dbConnection != null)
{
try
{
dbConnection.Close();
dbConnection.Dispose();
}
catch
{

}
}
}
}
/// <summary>
/// Reader转化为实体数据前回调
/// 如果在事件回调函数中手工转换了，则系统不再进行自动转换
/// </summary>
public event DbDataReaderToEntityBegin<T> OnReaderToEntityBegin;
/// <summary>
/// Reader转化为实体数据完毕回调
/// 可以更改自动转换完毕的数据
/// </summary>
public event DbDataReaderToEntityEnd<T> OnReaderToEntityEnd;
/// <summary>
/// 设置Map配置映射
/// </summary>
/// <param name="classMapDataSource">Map配置</param>
public virtual void SetClassMapDataSource(ClassMapDataSource classMapDataSource)
{
this.classMapDataSource = classMapDataSource;
}
/// <summary>
/// 设置数据源
/// </summary>
/// <param name="dataSource">数据源信息</param>
public virtual void SetDataSource(DataSource dataSource)
{
this.dataSource = dataSource;
}
}

面向最终的调用实现，作为面向服务实现的具体服务方法，因为除了要承载数据库访问操作或调用，还要承载远程通信等的服务接口调用，因此此处，抛弃了基于继承基类的实现方法，而是通过接口实现，采用组合实现，这样，可以在具体的方法上，实现多组组合的服务调用。

Demo中的实现作为测试，采用硬编码实现方式，而不是加载配置方式。

public class Test1Service:IEntityService<Test1>
{
private IEntityService<Test1> entityService;
/// <summary>
/// 获取实体服务类
/// </summary>
/// <returns></returns>
protected IEntityService<Test1> getEntityService()
{
if (entityService == null)
{
string connectString = "Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=localhost)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=Orcl)));Persist Security Info=True;User ID=TestOrcl;Password=Gbw1234567;";
ClassMapDataSource classMapDataSource = new ClassMapDataSource();
classMapDataSource.DataSourceType = DataSourceType.Oracle;
classMapDataSource.DataSourceKey = "Test";
classMapDataSource.EntityLoadType = EntityLoadType.MetaData;
classMapDataSource.ClassName = typeof(Test1).Name;
DataSource dataSource = new DataSource();
dataSource.DataSourceType = DataSourceType.Oracle;
dataSource.ConnectString = connectString;
dataSource.Key = "Test";
entityService = DataAccessFactory.CreateEntityService<Test1>(classMapDataSource);
entityService.SetDataSource(dataSource);
entityService.SetClassMapDataSource(classMapDataSource);
}
return entityService;
}

/// <summary>
/// 测试长连接数据保存
/// </summary>
/// <param name="list"></param>
[TransactionScopeOption(ScopeOption.Required)]
public virtual void SaveTempAll(BindingList<Test1> list)
{
for (int i = 0; i < list.Count; i++)
{
Test1 item = list[i];
getEntityService().Save(item,ConnectionType.EntityConnect);
}
}
public void SetClassMapDataSource(ClassMapDataSource classMapDataSource)
{
getEntityService().SetClassMapDataSource(classMapDataSource);
}

public void SetDataSource(DataSource dataSource)
{
getEntityService().SetDataSource(dataSource);
}

public int Count(Where where)
{
return getEntityService().Count(where);
}

public int Count(Where where, EntityCountCommandCallBack<Test1> onCountCommandCallBack, EnityCountParameterCallBack onCountParameterCallBack)
{
return getEntityService().Count(where, onCountCommandCallBack, onCountParameterCallBack);
}

public Test1 Delete(Test1 data, EntitySaveCommandCallBack<Test1> onDeleteCommandCallBack, EntitySaveParameterCallBack<Test1> onDeleteParamterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return getEntityService().Delete(data, onDeleteCommandCallBack, onDeleteParamterCallBack, connectionType);
}

public Test1 Delete(Test1 data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return getEntityService().Delete(data, connectionType);
}

public int Delete(Where where, EntityDeleteWhereCommandCallBack onDeleteWhereCommandCallBack, EntityDeleteWhereParameterCallBack onDeleteWhereParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
return getEntityService().Delete(where, onDeleteWhereCommandCallBack, onDeleteWhereParameterCallBack, connectionType);
}

public int Delete(Where where, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> DeleteCollection(Trace.Common.Data.DataCollection<Test1> list, EntitySaveCommandCallBack<Test1> onDeleteCommandCallBack, EntitySaveParameterCallBack<Test1> onDeleteParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> DeleteCollection(Trace.Common.Data.DataCollection<Test1> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public int ExcuteCommand(string commandText, Parameters parameters, EntityExcuteParameterCallBack onExcuteParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public int ExcuteCommand(string commandText, Parameters parameters, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public bool Exist(Test1 data)
{
throw new NotImplementedException();
}

public bool Exist(Test1 data, EntityExistCommandCallBack<Test1> onExistCommandCallBack, EntityExistParameterCallBack<Test1> onExistParameterCallBack)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, MaxRecords rowNumbers)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, MaxRecords rowNumbers, EntityFindCommandCallBack<Test1> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, Order order)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, Order order, MaxRecords rowNumbers)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, Order order, MaxRecords rowNumbers, EntityFindCommandCallBack<Test1> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, Order order, EntityFindCommandCallBack<Test1> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> Find(Where where, EntityFindCommandCallBack<Test1> onFindCommandCallBack, EnityFindParameterCallBack onFindParameterCallBack)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> FindByCommand(SQLCommandText commandText, Parameters parameters)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> FindByCommand(SQLCommandText commandText, Parameters parameters, EntityFindParameterCallBack onFindParameterCallBack)
{
throw new NotImplementedException();
}

public Test1 Insert(Test1 data, EntitySaveCommandCallBack<Test1> onInsertCommandCallBack, EntitySaveParameterCallBack<Test1> onInsertParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Test1 Insert(Test1 data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> InsertCollection(Trace.Common.Data.DataCollection<Test1> list, EntitySaveCommandCallBack<Test1> onInsertCommandCallBack, EntitySaveParameterCallBack<Test1> onInsertParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> InsertCollection(Trace.Common.Data.DataCollection<Test1> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Test1 Save(Test1 data, EntitySaveCommandCallBack<Test1> onSaveCommandCallBack, EntitySaveParameterCallBack<Test1> onSaveParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Test1 Save(Test1 data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> SaveCollection(Trace.Common.Data.DataCollection<Test1> list, EntitySaveCommandCallBack<Test1> onSaveCommandCallBack, EntitySaveParameterCallBack<Test1> onSaveParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> SaveCollection(Trace.Common.Data.DataCollection<Test1> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Test1 Update(Test1 data, EntitySaveCommandCallBack<Test1> onUpdateCommandCallBack, EntitySaveParameterCallBack<Test1> onUpdateParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Test1 Update(Test1 data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public int Update(UpdatePropertys update, Where where, EntityUpdatePropertysCommandCallBack onUpdatePropertysCommandCallBack, EntityUpdatePropertysWhereParameterCallBack onUpdatePropertysParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public int Update(UpdatePropertys update, Where where, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> UpdateCollection(Trace.Common.Data.DataCollection<Test1> list, EntitySaveCommandCallBack<Test1> onUpdateCommandCallBack, EntitySaveParameterCallBack<Test1> onUpdateParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Trace.Common.Data.DataCollection<Test1> UpdateCollection(Trace.Common.Data.DataCollection<Test1> list, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public event DbDataReaderToEntityBegin<Test1> OnReaderToEntityBegin;

public event DbDataReaderToEntityEnd<Test1> OnReaderToEntityEnd;

public Test1 Update(UpdatePropertys update, Test1 data, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}

public Test1 Update(UpdatePropertys update, Test1 data, EntityUpdateDataPropertysCommandCallBack<Test1> onUpdatePropertysCommandCallBack, EntityUpdatePropertysParameterCallBack<Test1> onUpdatePropertysParameterCallBack, ConnectionType connectionType = ConnectionType.GlobalConnect)
{
throw new NotImplementedException();
}
}

为了面向与具体的数据库访问操作无关性，需要引入的几个通用处理数据结构：

Parameter参数，用于数据库的参数传入、传出，通用替代SqlParamter或OracleParamter等

/// <summary>
/// 数据库参数信息
/// </summary>
[ProtoContract]
public class Parameter
{
/// <summary>
/// 数据库参数信息
/// </summary>
/// <param name="propertyName">属性名,用于框架加载对应的数据库映射配置信息</param>
/// <param name="parameterName">参数名称,用于数据库的参数传入、传出，参数前不需要添加特殊的传输符号，比如":","@",框架会自动对参数进行转化</param>
/// <param name="value">值</param>
public Parameter(string propertyName,string parameterName,object value)
{
this.propertyName = propertyName;
this.parameterName = parameterName;
this.dataValue = new Variant(value);
}
private string propertyName;
/// <summary>
/// 属性名称
/// </summary>
[ProtoMember(1)]
public string PropertyName
{
get { return propertyName; }
set { propertyName = value; }
}
private string parameterName;
/// <summary>
/// 参数名称,用于数据库的参数传入、传出，
/// 参数前不需要添加特殊的传输符号，比如":","@",框架会自动对参数进行转化
/// </summary>
[ProtoMember(2)]
public string ParameterName
{
get { return parameterName; }
set { parameterName = value; }
}
private Variant dataValue;
/// <summary>
/// 序列化得变量值
/// </summary>
[ProtoMember(3)]
public Variant DataValue
{
get { return dataValue; }
set { dataValue = value; }
}
}

SQLCommand用于不同的数据库的具体的SQL语句的传入，采用冗余实现方式，主要是不太认可Hibernate的HSQL，虽然能达到通用性，逼得开发人员需要关注第三种SQL

/// <summary>
/// SQL命令
/// </summary>
public  class SQLCommandText
{
private string oracleCommandText;
/// <summary>
/// Oracle下的SQL语句
/// </summary>
public string OracleCommandText
{
get { return oracleCommandText; }
set { oracleCommandText = value; }
}
private string sqlServerCommandText;
/// <summary>
/// SqlServer下的SQL语句
/// </summary>
public string SqlServerCommandText
{
get { return sqlServerCommandText; }
set { sqlServerCommandText = value; }
}
}

分页查询对象

/// <summary>
/// 查询数量
/// </summary>
[ProtoContract()]
public class MaxRecords
{
/// <summary>
/// 查询指定行数的数据
/// </summary>
/// <param name="recordNumbers">查询的最大行数,如果是-1，默认查询所有符合条件的数据</param>
public MaxRecords(int recordNumbers = -1)
{
this.recordNumbers = recordNumbers;
}
/// <summary>
/// 查询的最大行数
/// 根据起始行数和查询的
/// </summary>
/// <param name="recordNumbers">查询的最大行数,如果是-1，默认查询所有符合条件的数据</param>
/// <param name="beginIndex">起始行序号</param>
public MaxRecords(int recordNumbers = -1, int beginIndex = 0)
{
this.recordNumbers = recordNumbers;
this.beginIndex = beginIndex;
}
private int recordNumbers = 1;
/// <summary>
/// 查询的最大行数
/// </summary>
[ProtoMember(1)]
public int RecordNumbers
{
get { return recordNumbers; }
set { recordNumbers = value; }
}
private int beginIndex = 0;
/// <summary>
/// 起始索引位置
/// </summary>
[ProtoMember(2)]
public int BeginIndex
{
get { return beginIndex; }
set { beginIndex = value; }
}
}

Oracle 动态SQL生成

/// <summary>
/// Oracle数据库对应的OR命令语句生成
/// </summary>
internal static class OracleCommandHelper
{
/// <summary>
/// 创建Select语句
/// </summary>
/// <param name="entity">构建实体</param>
/// <returns></returns>
public static string CreateEntitySelectCommand(Entity entity)
{
TableAttribute tableAttribute = entity.TableAttribute;
if (tableAttribute == null)
{
throw new Exception("加载实体类的数据库Select映射失败，无表属性映射");
}
List<EntityProperty> entityPropertyList = entity.EntityPropertyList;
if (entityPropertyList == null || entityPropertyList.Count == 0)
{
throw new Exception("加载实体类的数据库Select映射失败，无列属性映射");
}
System.Text.StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.Append("Select  ");
List<string> keyList = new List<string>();
for (int i = 0; i < entityPropertyList.Count; i++)
{
EntityProperty property = entityPropertyList[i];
if (property.ColumnAttribute == null)
{
continue;
}
sqlBuilder.Append(property.ColumnAttribute.ColumnName);
if (i != entityPropertyList.Count - 1)
{
sqlBuilder.Append(",");
}
if (property.KeyAttribute != null)
{
string key = string.Format("{0}=:{1}", property.ColumnAttribute.ColumnName, property.PropertyName);
keyList.Add(key);
}
}
if (keyList.Count == 0)
{
throw new Exception(string.Format("表{0}未设置主键或联合主键", tableAttribute.TableName));
}
System.Text.StringBuilder keyBuilder = new StringBuilder();
for (int i = 0; i < keyList.Count; i++)
{
keyBuilder.Append(keyList[i]);
if (i != (keyList.Count - 1))
{
keyBuilder.Append(" and ");
}
}
sqlBuilder.Append(" from ");
sqlBuilder.Append(tableAttribute.TableName);
sqlBuilder.Append(" where ");
sqlBuilder.Append(keyBuilder.ToString());
return sqlBuilder.ToString();
}
/// <summary>
/// 创建Insert语句
/// </summary>
/// <param name="entity">构建实体</param>
/// <returns></returns>
public static string CreateEntityInsertCommand(Entity entity)
{
TableAttribute tableAttribute = entity.TableAttribute;
if (tableAttribute == null)
{
throw new Exception("加载实体类的数据库Insert映射失败，无表属性映射");
}
List<EntityProperty> entityPropertyList = entity.EntityPropertyList;
if (entityPropertyList == null || entityPropertyList.Count == 0)
{
throw new Exception("加载实体类的数据库Insert映射失败，无列属性映射");
}
System.Text.StringBuilder columnBuilder = new StringBuilder();
System.Text.StringBuilder parameterBuilder = new StringBuilder();
for (int i = 0; i < entityPropertyList.Count; i++)
{
EntityProperty property = entityPropertyList[i];
if (property.ColumnAttribute == null)
{
continue;
}
columnBuilder.Append(property.ColumnAttribute.ColumnName);
if (i != (entityPropertyList.Count - 1))
{
columnBuilder.Append(",");
}
parameterBuilder.Append(":");
parameterBuilder.Append(property.PropertyName);
if (i != (entityPropertyList.Count - 1))
{
parameterBuilder.Append(",");
}
}
System.Text.StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.Append("Insert into ");
sqlBuilder.Append(tableAttribute.TableName);
sqlBuilder.Append(" (");
sqlBuilder.Append(columnBuilder.ToString());
sqlBuilder.Append(") values (");
sqlBuilder.Append(parameterBuilder.ToString());
sqlBuilder.Append(")");
return sqlBuilder.ToString();
}
/// <summary>
/// 创建Update语句
/// </summary>
/// <param name="entity">构建实体</param>
/// <returns></returns>
public static string CreateEntityUpdateCommand(Entity entity)
{
TableAttribute tableAttribute = entity.TableAttribute;




Oracle 动态参数生成

internal static class OracleParameterHelper
{
/// <summary>
/// 创建Select语句
/// </summary>
/// <param name="entity">构建实体描述</param>
/// <param name="item">实体对象</param>
/// <returns></returns>
public static OracleParameter[] CreateEntitySelectParameter<T>(Entity entity, T item)
{
TableAttribute tableAttribute = entity.TableAttribute;
if (tableAttribute == null)
{
throw new Exception("加载实体类的数据库Select映射失败，无表属性映射");
}
List<OracleParameter> paramerters = new List<OracleParameter>();
List<EntityProperty> entityPropertyList = entity.EntityPropertyList;
int keyCount = 0;
for (int i = 0; i < entityPropertyList.Count; i++)
{
EntityProperty property = entityPropertyList[i];
if (property.ColumnAttribute == null)
{
continue;
}
if (property.KeyAttribute == null)
{
continue;
}
keyCount += 1;
OracleParameter parameter = PropertyToParameter(property);
object value = property.PropertyInfo.GetValue(item, null);
if (value == null)
{
OracleColumnAttribute oracleColumnAttribute = (OracleColumnAttribute)property.ColumnAttribute;
if (property.KeyAttribute != null)
{
throw new Exception(string.Format("构建SelectParameter失败，属性【{0}】对应的表【{1}】列【{2}】为主键，但是未赋值", property.PropertyName, tableAttribute.TableName, oracleColumnAttribute.ColumnName));
}
}
else
{
parameter.Value = value;
}
paramerters.Add(parameter);
}
if (tableAttribute.TableKeyType == TableKeyType.单一主键)
{
if (keyCount != 1)
{
throw new Exception(string.Format("构建SelectParameter失败,当前实体的Table属性设置为【{0}】,但是检测到【{1}】个主键,主键必须唯一", tableAttribute.TableKeyType.ToString(), keyCount));
}
}
else if (tableAttribute.TableKeyType == TableKeyType.联合主键)
{
if (keyCount <= 1)
{
throw new Exception(string.Format("构建SelectParameter失败,当前实体的Table属性设置为【{0}】,但是检测到【{1}】个主键，主键必须大于1", tableAttribute.TableKeyType.ToString(), keyCount));
}
}
return paramerters.ToArray();
}

/// <summary>
/// 创建Insert语句
/// </summary>
/// <param name="entity">构建实体描述</param>
/// <param name="item">实体对象</param>
/// <returns></returns>
public static OracleParameter[] CreateEntityInsertParameter<T>(Entity entity,T item)
{
TableAttribute tableAttribute = entity.TableAttribute;
if (tableAttribute == null)
{
throw new Exception("加载实体类的数据库Insert映射失败，无表属性映射");
}
List<OracleParameter> paramerters = new List<OracleParameter>();
List<EntityProperty> entityPropertyList = entity.EntityPropertyList;
int keyCount = 0;
for (int i = 0; i < entityPropertyList.Count; i++)
{
EntityProperty property = entityPropertyList[i];
if (property.ColumnAttribute == null)
{
continue;
}
if (property.KeyAttribute != null)
{
keyCount +=1;
}
OracleParameter parameter = PropertyToParameter(property);
object value = property.PropertyInfo.GetValue(item, null);
if (value == null)
{
OracleColumnAttribute oracleColumnAttribute = (OracleColumnAttribute)property.ColumnAttribute;
if (oracleColumnAttribute.ColumnIsNull == false)
{
throw new Exception(string.Format("构建InsertParameter失败，属性【{0}】对应的表【{1}】列【{2}】不为空，但是未赋值", property.PropertyName, tableAttribute.TableName, oracleColumnAttribute.ColumnName));
}
if (property.KeyAttribute != null)
{
throw new Exception(string.Format("构建InsertParameter失败，属性【{0}】对应的表【{1}】列【{2}】为主键，但是未赋值", property.PropertyName, tableAttribute.TableName, oracleColumnAttribute.ColumnName));
}
parameter.Value = DBNull.Value;
}
else
{
parameter.Value = value;
}
paramerters.Add(parameter);
}
if (tableAttribute.TableKeyType == TableKeyType.单一主键)
{
if (keyCount != 1)
{
throw new Exception(string.Format("构建InsertParameter失败，当前实体的Table属性设置为【{0}】,但是检测到【{1}】个主键,主键必须唯一", tableAttribute.TableKeyType.ToString(), keyCount));
}
}
else if (tableAttribute.TableKeyType == TableKeyType.联合主键)
{
if (keyCount <= 1)
{
throw new Exception(string.Format("构建InsertParameter失败，当前实体的Table属性设置为【{0}】,但是检测到【{1}】个主键，主键必须大于1", tableAttribute.TableKeyType.ToString(), keyCount));
}
}
return paramerters.ToArray();
}
/// <summary>
/// 创建Update语句
/// </summary>
/// <param name="entity">构建实体描述</param>
/// <param name="item">实体对象</param>
/// <returns></returns>
public static OracleParameter[] CreateEntityUpdateParameter<T>(Entity entity, T item)
{
TableAttribute tableAttribute = entity.TableAttribute;
if (tableAttribute == null)
{
throw new Exception("加载实体类的数据库Update映射失败，无表属性映射");
}
List<OracleParameter> paramerters = new List<OracleParameter>();
List<EntityProperty> entityPropertyList = entity.EntityPropertyList;
int keyCount = 0;
for (int i = 0; i < entityPropertyList.Count; i++)
{
EntityProperty property = entityPropertyList[i];
if (property.ColumnAttribute == null)
{
continue;
}


除了实体操作之外，还需要面向一些复杂的报表处理等，复合SQL查询语句，Hibernate中统一采用HSQL,但是因为对这个实在是不感冒，所以对查询接口部分，还是老老实实，采用原生态SQL，这个可能是从软件设计的纯粹角度一些不合理的地方吧，但是采用冗余设计方案，把所有可能的数据库访问层的SQL语句，预先都写入或写好，这是采用的策略。

这个查询服务接口的核心思想是，无论多么复杂的SQL，最终都是转化为表数据，对应的行、列都能一一映射到数据实体的对象和集合上，因此查询服务接口的T，作为范型数据源，就会有不同的类或对象定义。

/// <summary>
/// 查询服务映射接口
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IQueryService<T>
where T : Trace.Common.Data.TraceData
{
/// <summary>
/// 设置Map配置映射
/// 主要用于代码调用，此时配置文件信息无效
/// </summary>
/// <param name="classMapDataSource">Map配置</param>
void SetClassMapDataSource(ClassMapDataSource classMapDataSource);
/// <summary>
/// 设置数据源
/// 主要用于代码设置调用，此时配置文件信息无效
/// </summary>
/// <param name="dataSource">数据源信息</param>
void SetDataSource(DataSource dataSource);
/// <summary>
/// 根据SQL查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL语句</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText);
/// <summary>
/// 根据SQL和Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where);
/// <summary>
/// 根据SQL和Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据SQL查询条件和数据库参数查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters);
/// <summary>
/// 根据SQL查询条件和数据库参数查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, MaxRecords rowNumbers);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, MaxRecords rowNumbers, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="rowNumbers">记录行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, MaxRecords rowNumbers);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, MaxRecords rowNumbers, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据SQL和Where查询条件查询，并自动排序
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, Order order);
/// <summary>
/// 根据SQL和Where查询条件查询，并自动排序
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, Order order, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="order">排序条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, Order order);
/// <summary>
/// 根据SQL和数据库输入参数查询，并自动排序
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="order">排序条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, Order order, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, Order order, MaxRecords rowNumbers);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> FindWhere(SQLCommandText sqlCommandText, Where where, Order order, MaxRecords rowNumbers, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库输入参数</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, Order order, MaxRecords rowNumbers);
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
Trace.Common.Data.DataCollection<T> FindParameter(SQLCommandText sqlCommandText, Parameters parameters, Order order, MaxRecords rowNumbers, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack);
/// <summary>
/// Reader转化为实体数据前回调
/// 如果在事件回调函数中手工转换了，则系统不再进行自动转换
/// </summary>
event DbDataReaderToEntityBegin<T> OnReaderToEntityBegin;
/// <summary>
/// Reader转化为实体数据完毕回调
/// 可以更改自动转换完毕的数据
/// </summary>
event DbDataReaderToEntityEnd<T> OnReaderToEntityEnd;
}


面向Oracle的查询服务实现：

/// <summary>
/// Oracle数据库查询服务
/// </summary>
/// <typeparam name="T"></typeparam>
public class OracleQueryService<T> : IQueryService<T> where T : Trace.Common.Data.TraceData
{
private ClassMapDataSource classMapDataSource;
/// <summary>
/// 获取配置映射
/// </summary>
/// <returns></returns>
protected ClassMapDataSource GetClassMapDataSource()
{
if (classMapDataSource != null)
{
return classMapDataSource;
}
ClassMapDataSource tempClassMapDataSource = ClassMapDataSourceHelper.Load<T>();
if (tempClassMapDataSource == null)
{
throw new Exception("获取实体类到数据库的映射配置失败");
}
classMapDataSource = tempClassMapDataSource;
return classMapDataSource;
}
/// <summary>
/// 数据源
/// </summary>
private DataSource dataSource;
/// <summary>
/// 获取数据源
/// </summary>
/// <returns></returns>
protected DataSource GetDataSource()
{
if (dataSource != null)
{
return dataSource;
}
ClassMapDataSource tempClassMapDataSource=GetClassMapDataSource();
DataSource tempDataSource = DataSourceHelper.Load(tempClassMapDataSource);
if (tempDataSource == null)
{
throw new Exception("获取数据源配置失败");
}
if (tempDataSource.DataSourceType != DataSourceType.Oracle)
{
throw new Exception("当前数据源连接字符串不是有效的Oracle连接字符串");
}
dataSource = tempDataSource;
return dataSource;
}
/// <summary>
/// 数据转化处理实体
/// </summary>
private Entity entity = null;
/// <summary>
/// 获取实体映射
/// </summary>
/// <returns></returns>
protected Entity getEntity()
{
if (entity == null)
{
ClassMapDataSource tempClassMapDataSource = GetClassMapDataSource();
this.entity = OracleEntityHelper.Load<T>(tempClassMapDataSource.EntityLoadType);
}
if (entity == null)
{
throw new Exception("获取实体对应的数据库配置映射失败");
}
return entity;
}
/// <summary>
/// 根据SQL查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL语句</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText)
{
return this.FindWhere(sqlCommandText, null, null, null, null, null);
}
/// <summary>
/// 根据SQL和Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where)
{
return this.FindWhere(sqlCommandText, where, null, null, null, null);
}
/// <summary>
/// 根据SQL和Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack)
{
return this.FindWhere(sqlCommandText, where, null, null, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据SQL查询条件和数据库参数查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters)
{
return this.FindParameter(sqlCommandText, parameters, null, null, null, null);
}
/// <summary>
/// 根据SQL查询条件和数据库参数查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack)
{
return this.FindParameter(sqlCommandText, parameters, null, null, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, MaxRecords maxRecords)
{
return this.FindWhere(sqlCommandText, where, null, maxRecords, null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, MaxRecords maxRecords, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack)
{
return this.FindWhere(sqlCommandText, where, null, maxRecords, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="rowNumbers">记录行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, MaxRecords maxRecords)
{
return this.FindParameter(sqlCommandText, parameters, null, maxRecords, null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, MaxRecords maxRecords, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack)
{
return this.FindParameter(sqlCommandText, parameters, null, maxRecords, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据SQL和Where查询条件查询，并自动排序
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, Order order)
{
return this.FindWhere(sqlCommandText, where, order, null, null, null);
}
/// <summary>
/// 根据SQL和Where查询条件查询，并自动排序
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, Order order, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack)
{
return this.FindWhere(sqlCommandText, where, order, null, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="order">排序条件</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, Order order)
{
return this.FindParameter(sqlCommandText, parameters, order, null, null, null);
}
/// <summary>
/// 根据SQL和数据库输入参数查询，并自动排序
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="order">排序条件</param>
/// <param name="onFindCommandCallBack">构建命令回调</param>
/// <param name="onFindParameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, Order order, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack)
{
return this.FindParameter(sqlCommandText, parameters, order, null, onFindCommandCallBack, onFindParameterCallBack);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Where where, Order order, MaxRecords maxRecords)
{
return this.FindWhere(sqlCommandText, where, order, maxRecords, null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="where">where查询条件</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> FindWhere(SQLCommandText sqlCommandText, Where where, Order order, MaxRecords maxRecords, QueryFindCommandCallBack onFindCommandCallBack, QueryFindWhereParametersCallBack onFindParameterCallBack)
{
Entity tempEntity = getEntity();
string commandText = null;
StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.Append(sqlCommandText);
if (where != null)
{
string whereText = OracleCommandHelper.CreateQueryWhereCommand(tempEntity, where);
if (!string.IsNullOrEmpty(whereText))
{
sqlBuilder.Append(" where ");
sqlBuilder.Append(whereText);
}
}
if (maxRecords != null && maxRecords.RecordNumbers > 0)
{
commandText = string.Format("Select * from ({0}) temp_t where RowNum>={1} and RowNum<={2}", sqlBuilder.ToString(), maxRecords.BeginIndex, maxRecords.RecordNumbers);
}
else
{
commandText = sqlBuilder.ToString();
}
if (order != null)
{
string orderText = OracleCommandHelper.QueryOrderToCommand(tempEntity, order);
if (!string.IsNullOrEmpty(orderText))
{
commandText = string.Format("{0} {1}", commandText, orderText);
}
}
if (onFindCommandCallBack != null)
{
commandText = onFindCommandCallBack(sqlCommandText, where, order,maxRecords, commandText, DataSourceType.Oracle);
}
OracleParameter[] oracleParameters = OracleParameterHelper.CreateQueryWhereParameters(tempEntity, where);
if (onFindParameterCallBack != null)
{
oracleParameters = (OracleParameter[])onFindParameterCallBack(where, oracleParameters, DataSourceType.Oracle);
}
return Find(commandText, oracleParameters);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库输入参数</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> Find(SQLCommandText sqlCommandText, Parameters parameters, Order order, MaxRecords maxRecords)
{
return this.FindParameter(sqlCommandText, parameters, order, maxRecords, null, null);
}
/// <summary>
/// 根据Where查询条件查询
/// </summary>
/// <param name="sqlCommandText">SQL查询条件</param>
/// <param name="parameters">数据库参数</param>
/// <param name="order">排序条件</param>
/// <param name="rowNumbers">查询符合条件的行数</param>
/// <param name="commandTextCallBack">构建命令回调</param>
/// <param name="parameterCallBack">参数回调</param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public DataCollection<T> FindParameter(SQLCommandText sqlCommandText, Parameters parameters, Order order, MaxRecords maxRecords, QueryFindCommandPasCallBack onFindCommandCallBack, QueryFindParametersCallBack onFindParameterCallBack)
{
Entity tempEntity = getEntity();
string commandText = sqlCommandText.OracleCommandText;
if (maxRecords != null && maxRecords.RecordNumbers > 0)
{
commandText = string.Format("Select * from ({0}) where RowNum>={1} and RowNum<={2}", commandText, maxRecords.BeginIndex, maxRecords.RecordNumbers);
}
if (order != null)
{
string orderText = OracleCommandHelper.QueryOrderToCommand(tempEntity, order);
if (!string.IsNullOrEmpty(orderText))
{
commandText = string.Format("{0} {1}", commandText, orderText);
}
}
if (onFindCommandCallBack != null)
{
commandText = onFindCommandCallBack(sqlCommandText, parameters, order, maxRecords, commandText, DataSourceType.Oracle);
}
OracleParameter[] oracleParameters = OracleParameterHelper.CreateQueryParameters(tempEntity, parameters);
if (onFindParameterCallBack != null)
{
oracleParameters = (OracleParameter[])onFindParameterCallBack(parameters, oracleParameters, DataSourceType.Oracle);
}
return Find(commandText, oracleParameters);
}
/// <summary>
/// 查询反馈数据
/// </summary>
/// <param name="commandText"></param>
/// <param name="oracleParameters"></param>
/// <returns></returns>
[TransactionScopeOption(ScopeOption.Suppress)]
public virtual DataCollection<T> Find(string commandText, OracleParameter[] oracleParameters)
{
OracleConnection connection = null;
DataCollection<T> list = new DataCollection<T>();
try
{
DataSource tempDataSource = GetDataSource();
connection = new OracleConnection(tempDataSource.ConnectString);
connection.Open();
OracleCommand command = connection.CreateCommand();
command.Parameters.Clear();
command.Parameters.AddRange(oracleParameters);
command.CommandText = commandText;
OracleDataReader reader = command.ExecuteReader();
while (reader.Read() == true)
{
T data = this.ChangeToData(reader);
data.SetDataState(DataState.Unchanged);
list.Add(data);
}
return list;
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (connection != null)
{
connection.Close();
}
}
}
/// <summary>
/// 创建数据实体
/// </summary>
/// <param name="reader">数据读取器</param>
/// <returns>
/// 返回对应读取到的数据实体
/// </returns>
protected virtual T ChangeToData(DbDataReader reader)
{
if (OnReaderToEntityBegin != null)
{
DbDataReaderBeginEventArgs<T> eBegin = new DbDataReaderBeginEventArgs<T>(reader);
OnReaderToEntityBegin(this, eBegin);
if (eBegin.Data != null)
{
if (OnReaderToEntityEnd != null)
{
DbDataReaderEndEventArgs<T> eEnd = new DbDataReaderEndEventArgs<T>(reader, eBegin.Data);
OnReaderToEntityEnd(this,eEnd);
return eEnd.Data;
}
}
}
Entity tempEntity = getEntity();
T data = Activator.CreateInstance<T>();
int count = reader.FieldCount;
for (int i = 0; i < count; i++)
{
if (reader.IsDBNull(i))
{
continue;
}
string columnName = reader.GetName(i);
EntityProperty entityProperty = tempEntity.FindEntityPropertyByColumnName(columnName);
if (entityProperty == null)
{
throw new Exception(string.Format("列{0}映射的实体数据属性不存在", columnName));
}
entityProperty.PropertyInfo.SetValue(data, reader[columnName], null);
}
if (OnReaderToEntityEnd != null)
{
DbDataReaderEndEventArgs<T> eEnd = new DbDataReaderEndEventArgs<T>(reader, data);
OnReaderToEntityEnd(this, eEnd);
return eEnd.Data;
}
return data;
}
/// <summary>
/// 获取打开连接
/// </summary>
/// <returns></returns>
private IDbConnection OpenConnection()
{
DataSource tempDataSource = GetDataSource();
IDbConnection tempDBConnection = new OracleConnection(tempDataSource.ConnectString);
tempDBConnection.Open();
return tempDBConnection;
}
/// <summary>
/// 关闭连接
/// 短连接直接关闭，长连接，利用事务环境进行关闭
/// </summary>
/// <param name="dbConnection">连接</param>
private void CloseConnection(IDbConnection dbConnection)
{
try
{
if (dbConnection != null)
{
dbConnection.Close();
dbConnection.Dispose();
}
}
catch
{

}
}
/// <summary>
/// Reader转化为实体数据前回调
/// 如果在事件回调函数中手工转换了，则系统不再进行自动转换
/// </summary>
public event DbDataReaderToEntityBegin<T> OnReaderToEntityBegin;
/// <summary>
/// Reader转化为实体数据完毕回调
/// 可以更改自动转换完毕的数据
/// </summary>
public event DbDataReaderToEntityEnd<T> OnReaderToEntityEnd;
/// <summary>
/// 设置Map配置映射
/// </summary>
/// <param name="classMapDataSource">Map配置</param>
public virtual void SetClassMapDataSource(ClassMapDataSource classMapDataSource)
{
this.classMapDataSource = classMapDataSource;
}
/// <summary>
/// 设置数据源
/// </summary>
/// <param name="dataSource">数据源信息</param>
public virtual void SetDataSource(DataSource dataSource)
{
this.dataSource = dataSource;
}
}