tijian_tieying/web/cyqdata-master/Action/MProc.cs

643 lines
20 KiB
C#
Raw Normal View History

2025-02-20 12:14:39 +08:00
using CYQ.Data.SQL;
using System.Data.SqlClient;
using System.Data;
using System;
using CYQ.Data.Table;
using CYQ.Data.Aop;
using System.Collections.Generic;
using CYQ.Data.Tool;
using System.Data.Common;
namespace CYQ.Data
{
/// <summary>
/// Manipulatesql / procedure
///<para>操作SQL或存储过程</para>
/// </summary>
public class MProc : IDisposable
{
/// <summary>
/// Change MAction to MProc
/// <para>将一个MAction 转换成一个MProc。</para>
/// </summary>
public static implicit operator MProc(MAction action)
{
return new MProc(action.dalHelper);
}
internal DbBase dalHelper;
private NoSqlCommand _noSqlCommand;
private InterAop _aop = new InterAop();
// private AopInfo _aopInfo = new AopInfo();
private string _procName = string.Empty;
private bool _isProc = true;
private string _debugInfo = string.Empty;
/// <summary>
/// 原始传进进来的链接。
/// </summary>
private string _conn = string.Empty;
/// <summary>
/// Get or set debugging information [need to set App Config.Debug.Open DebugInfo to ture]
///<para>获取或设置调试信息[需要设置AppConfig.Debug.OpenDebugInfo为ture]</para>
/// </summary>
public string DebugInfo
{
get
{
if (dalHelper != null)
{
return dalHelper.debugInfo.ToString();
}
return _debugInfo;
}
}
/// <summary>
/// The database type
/// <para>数据库类型</para>
/// </summary>
public DalType DalType
{
get
{
return dalHelper.dalType;
}
}
/// <summary>
/// The database name
/// <para>数据库名称</para>
/// </summary>
public string DataBase
{
get
{
return dalHelper.DataBase;
}
}
/// <summary>
/// The database version
/// 数据库的版本号
/// </summary>
public string DalVersion
{
get
{
return dalHelper.Version;
}
}
/// <summary>
/// The number of rows affected when executing a SQL command (-2 is an exception)
/// <para>执行SQL命令时受影响的行数-2则为异常。</para>
/// </summary>
public int RecordsAffected
{
get
{
return dalHelper.recordsAffected;
}
}
/// <summary>
/// The database connection string
///<para>数据库链接字符串</para>
/// </summary>
public string ConnectionString
{
get
{
if (dalHelper != null)
{
return dalHelper.conn;
}
return string.Empty;
}
}
/// <summary>
/// Command Timeout[seconds]
///<para>命令超时设置[单位秒]</para>
/// </summary>
public int TimeOut
{
get
{
if (dalHelper.Com != null)
{
return dalHelper.Com.CommandTimeout;
}
return -1;
}
set
{
if (dalHelper.Com != null)
{
dalHelper.Com.CommandTimeout = value;
}
}
}
/// <summary>
/// Instantiation
/// <para>实例化</para>
/// </summary>
/// <param name="procNameOrSql">Parameters: sql or procedure
/// <para>参数SQL语句或存储过程名称</para></param>
public MProc(object procNameOrSql)
{
Init(procNameOrSql, AppConfig.DB.DefaultConn);
}
public MProc(object procNameOrSql, string conn)
{
Init(procNameOrSql, conn);
}
internal MProc(DbBase dbBase)
{
_procName = string.Empty;
_conn = dbBase.conn;
SetDbBase(dbBase);
}
private void Init(object procNameOrSql, string conn)
{
#region Sql或者存储过程
if (procNameOrSql != null)
{
if (procNameOrSql is Enum)
{
Type t = procNameOrSql.GetType();
string enumName = t.Name;
if (enumName != "ProcNames")
{
if (enumName.Length > 1 && enumName[1] == '_')
{
conn = enumName.Substring(2).Replace("Enum", "Conn");
}
else
{
string[] items = t.FullName.Split('.');
if (items.Length > 1)
{
conn = items[items.Length - 2] + "Conn";
items = null;
}
}
}
t = null;
}
_procName = procNameOrSql.ToString().Trim();
_isProc = _procName.IndexOf(' ') == -1;//不包含空格
}
#endregion
_conn = conn;
SetDbBase(DalCreate.CreateDal(conn));
}
private void SetDbBase(DbBase dbBase)
{
dalHelper = dbBase;
if (dalHelper.IsOnExceptionEventNull)
{
dalHelper.OnExceptionEvent += new DbBase.OnException(helper_OnExceptionEvent);
}
switch (dalHelper.dalType)
{
case DalType.Txt:
case DalType.Xml:
_noSqlCommand = new NoSqlCommand(_procName, dalHelper);
break;
}
//Aop.IAop myAop = Aop.InterAop.Instance.GetFromConfig();//试图从配置文件加载自定义Aop
//if (myAop != null)
//{
// SetAop(myAop);
//}
}
/// <summary>
/// <param name="isClearPara">IsClearParameters
/// <para>是否清除参数</para></param>
/// </summary>
public void ResetProc(object procNameOrSql, bool isClearPara)
{
_procName = procNameOrSql.ToString().Trim();
if (isClearPara)
{
dalHelper.ClearParameters();
}
_isProc = _procName.IndexOf(' ') == -1;//不包含空格
switch (dalHelper.dalType)
{
case DalType.Txt:
case DalType.Xml:
_noSqlCommand = null;
_noSqlCommand = new NoSqlCommand(_procName, dalHelper);
break;
}
}
///<summary>
/// Toggle tProc Action: To switch between other sql/procedure, use this method
/// <para>切换操作:如需操作其它语句或存储过程,通过此方法切换</para>
/// </summary>
/// <param name="procNameOrSql">Parameters: sql or procedure
/// <para>参数存储过程名或Sql语句</para></param>
public void ResetProc(object procNameOrSql)
{
ResetProc(procNameOrSql, true);
}
private AopResult SetAopResult(AopEnum action)
{
if (_aop.IsLoadAop)
{
_aop.Para.MProc = this;
_aop.Para.ProcName = _procName;
_aop.Para.IsProc = _isProc;
if (dalHelper.Com != null)
{
_aop.Para.DBParameters = dalHelper.Com.Parameters;
}
_aop.Para.IsTransaction = dalHelper.isOpenTrans;
return _aop.Begin(action);
}
return AopResult.Default;
}
/// <summary>
/// Get MDataTable
/// </summary>
public MDataTable ExeMDataTable()
{
CheckDisposed();
AopResult aopResult = SetAopResult(AopEnum.ExeMDataTable);
if (aopResult == AopResult.Return)
{
return _aop.Para.Table;
}
else
{
if (aopResult != AopResult.Break)
{
switch (dalHelper.dalType)
{
case DalType.Txt:
case DalType.Xml:
_aop.Para.Table = _noSqlCommand.ExeMDataTable();
break;
default:
_aop.Para.Table = dalHelper.ExeDataReader(_procName, _isProc);
_aop.Para.Table.Columns.dalType = DalType;
// dalHelper.ResetConn();//重置Slave
break;
}
_aop.Para.Table.Conn = _conn;
_aop.Para.IsSuccess = _aop.Para.Table.Rows.Count > 0;
}
if (aopResult != AopResult.Default)
{
_aop.End(AopEnum.ExeMDataTable);
}
return _aop.Para.Table;
}
}
/// <summary>
/// Get MDataTables
/// </summary>
public List<MDataTable> ExeMDataTableList()
{
CheckDisposed();
AopResult aopResult = SetAopResult(AopEnum.ExeMDataTableList);
if (aopResult == AopResult.Return)
{
return _aop.Para.TableList;
}
else
{
if (aopResult != AopResult.Break)
{
List<MDataTable> dtList = new List<MDataTable>();
switch (dalHelper.dalType)
{
case DalType.Txt:
case DalType.Xml:
case DalType.Oracle:
if (_isProc && dalHelper.dalType == DalType.Oracle)
{
goto isProc;
}
foreach (string sql in _procName.TrimEnd(';').Split(';'))
{
MDataTable dt = null;
if (dalHelper.dalType == DalType.Oracle)
{
dt = dalHelper.ExeDataReader(sql, false);
}
else
{
_noSqlCommand.CommandText = sql;
dt = _noSqlCommand.ExeMDataTable();
}
if (dt != null)
{
dtList.Add(dt);
}
}
break;
default:
isProc:
DbDataReader reader = dalHelper.ExeDataReader(_procName, _isProc);
if (reader != null)
{
do
{
dtList.Add(MDataTable.CreateFrom(reader));
}
while (reader.NextResult());
reader.Close();
reader.Dispose();
reader = null;
}
break;
}
_aop.Para.TableList = dtList;
_aop.Para.IsSuccess = dtList.Count > 0;
}
if (aopResult != AopResult.Default)
{
_aop.End(AopEnum.ExeMDataTableList);
}
return _aop.Para.TableList;
}
}
/// <summary>
/// Returns the number of rows affected [used to insert update or delete], and returns -2 if an exception is executed
/// <para>返回受影响的行数[用于更新或删除],执行异常时返回-2</para>
/// </summary>
public int ExeNonQuery()
{
CheckDisposed();
AopResult aopResult = SetAopResult(AopEnum.ExeNonQuery);
if (aopResult == AopResult.Return)
{
return _aop.Para.RowCount;
}
else
{
if (aopResult != AopResult.Break)
{
switch (dalHelper.dalType)
{
case DalType.Txt:
case DalType.Xml:
_aop.Para.RowCount = _noSqlCommand.ExeNonQuery();
break;
default:
_aop.Para.RowCount = dalHelper.ExeNonQuery(_procName, _isProc);
break;
}
_aop.Para.IsSuccess = _aop.Para.RowCount > 0;
}
if (aopResult != AopResult.Default)
{
_aop.End(AopEnum.ExeNonQuery);
}
return _aop.Para.RowCount;
}
}
/// <summary>
/// Returns the value of the first column of the first row
/// <para>返回首行首列的值</para>
/// </summary>
public T ExeScalar<T>()
{
CheckDisposed();
AopResult aopResult = SetAopResult(AopEnum.ExeScalar);
if (aopResult == AopResult.Default || aopResult == AopResult.Continue)
{
switch (dalHelper.dalType)
{
case DalType.Txt:
case DalType.Xml:
_aop.Para.ExeResult = _noSqlCommand.ExeScalar();
break;
default:
_aop.Para.ExeResult = dalHelper.ExeScalar(_procName, _isProc);
break;
}
_aop.Para.IsSuccess = _aop.Para.ExeResult != null;
}
if (aopResult == AopResult.Continue || aopResult == AopResult.Break)
{
_aop.End(AopEnum.ExeScalar);
}
if (_aop.Para.ExeResult == null || _aop.Para.ExeResult == DBNull.Value)
{
return default(T);
}
Type t = typeof(T);
object value = _aop.Para.ExeResult;
switch (t.Name)
{
case "Int32":
int intValue = 0;
if (!int.TryParse(Convert.ToString(value), out intValue))
{
return default(T);
}
value = intValue;
break;
default:
try
{
value = StaticTool.ChangeType(value, t);
}
catch
{
}
break;
}
return (T)value;
}
/// <summary>
/// <para>Set Input Para</para>
/// <para>设置存储过程Input参数</para>
/// </summary>
public MProc Set(object paraName, object value)
{
dalHelper.AddParameters(Convert.ToString(paraName), value); return this;
}
public MProc Set(object paraName, object value, DbType dbType)
{
dalHelper.AddParameters(Convert.ToString(paraName), value, dbType, -1, ParameterDirection.Input); return this;
}
/// <summary>
/// 设置特殊自定义参数
/// </summary>
public MProc SetCustom(object paraName, ParaType paraType)
{
return SetCustom(paraName, paraType, null, null);
}
/// <summary>
/// <para>Set the stored procedure OutPut, the return value and other special types of parameters</para>
/// <para>设置存储过程OutPut、返回值等特殊类型参数</para>
/// </summary>
public MProc SetCustom(object paraName, ParaType paraType, object value)
{
return SetCustom(paraName, paraType, value, null);
}
/// <param name="typeName">MSSQL The name of the user-defined table type<para>MSSQL的用户定义表类型的名称</para></param>
public MProc SetCustom(object paraName, ParaType paraType, object value, string typeName)
{
dalHelper.AddCustomePara(Convert.ToString(paraName), paraType, value, typeName); return this;
}
/// <summary>
/// Clear Parameters
/// <para>清除存储过程参数</para>
/// </summary>
public void Clear()
{
dalHelper.ClearParameters();
}
/// <summary>
/// Get Procedure Return Value
/// <para>存储过程的返回值</para>
/// </summary>
public int ReturnValue
{
get
{
return dalHelper.ReturnValue;
}
}
/// <summary>
/// The OutPut value for the stored procedure: Dictionary for multiple values
/// <para>存储过程的OutPut值多个值时为Dictionary</para>
/// </summary>
public object OutPutValue
{
get
{
return dalHelper.OutPutValue;
}
}
#region Aop
/// <summary>
/// Set Aop State
/// <para>设置Aop状态</para>
/// </summary>
public MProc SetAopState(AopOp op)
{
_aop.aopOp = op;
return this;
}
/// <summary>
/// Pass additional parameters for Aop use
/// <para>传递额外的参数供Aop使用</para>
/// </summary>
public MProc SetAopPara(object para)
{
_aop.Para.AopPara = para;
return this;
}
void helper_OnExceptionEvent(string errorMsg)
{
_aop.OnError(errorMsg);
}
#endregion
#region
/// <summary>
/// Set the transaction level
/// <para>设置事务级别</para>
/// </summary>
/// <param name="level">IsolationLevel</param>
public MProc SetTransLevel(IsolationLevel level)
{
dalHelper.TranLevel = level; return this;
}
/// <summary>
/// Begin Transation
/// <para>开始事务</para>
/// </summary>
public void BeginTransation()
{
dalHelper.isOpenTrans = true;
}
/// <summary>
/// Commit Transation
/// <para>提交事务</para>
/// </summary>
public bool EndTransation()
{
if (dalHelper != null && dalHelper.isOpenTrans)
{
return dalHelper.EndTransaction();
}
return false;
}
/// <summary>
/// RollBack Transation
/// <para>事务回滚</para>
/// </summary>
public bool RollBack()
{
if (dalHelper != null && dalHelper.isOpenTrans)
{
return dalHelper.RollBack();
}
return false;
}
#endregion
#region IDisposable
/// <summary>
/// Dispose
/// <para>释放资源</para>
/// </summary>
public void Dispose()
{
hasDisposed = true;
if (dalHelper != null)
{
if (!dalHelper.IsOnExceptionEventNull)
{
dalHelper.OnExceptionEvent -= new DbBase.OnException(helper_OnExceptionEvent);
}
_debugInfo = dalHelper.debugInfo.ToString();
dalHelper.Dispose();
dalHelper = null;
}
if (_noSqlCommand != null)
{
_noSqlCommand.Dispose();
}
}
bool hasDisposed = false;
private void CheckDisposed()
{
if (hasDisposed)
{
Error.Throw("The current object 'MProc' has been disposed");
}
}
#endregion
}
}