public IConnection BuildConnection(DbEnum dbType)
{
var dbConfig = DbConfigService.GetInstance(dbType);
var connString = dbConfig.CreateConfigJson();
return(InitializeConnection(connString));
}
public DbConfig(string name, DbEnum type, string connStr, bool isTest) : this()
{
Name = name;
Type = type;
ConnectionString = connStr;
IsTest = isTest;
}
public static DbContext Create(DbEnum dbEnum)
{
switch (dbEnum)
{
case DbEnum.DataMart:
return(new DbContext()
{
Server = "DataMart",
ConnectionStr = "DataMart connection string"
});
case DbEnum.History:
return(new DbContext()
{
Server = "History",
ConnectionStr = "History connection string"
});
case DbEnum.Online:
return(new DbContext()
{
Server = "Online",
ConnectionStr = "Online connection string"
});
default:
throw new Exception("No mapping database settings!");
}
}
public DbConfig(string name, DbEnum type, string connStr, bool isTest) : this()
{
ConnectionString = connStr ?? throw new ArgumentNullException("ConnectionString cannot be null.");
IsConnectionStringTemplate = connStr.Contains('{');
Name = name;
Type = type;
IsTest = isTest;
}
internal ParamTypeEnum Float(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
case DbEnum.SQLServer:
return(ParamTypeEnum.Float_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum VarChar(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
case DbEnum.SQLServer:
return(ParamTypeEnum.VarChar_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum Decimal(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
case DbEnum.SQLServer:
return(ParamTypeEnum.Decimal_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum TimeSpanProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
case DbEnum.SQLServer:
return(ParamTypeEnum.Time_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum ShortProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
case DbEnum.SQLServer:
return(ParamTypeEnum.SmallInt_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum BoolProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
case DbEnum.SQLServer:
return(ParamTypeEnum.Bit_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
public static IDbConfigService GetInstance(DbEnum dbType)
{
if (_instance == null)
{
_instance = new DbConfigService(dbType);
}
else
{
_instance.DbType = dbType;
}
return(_instance);
}
public IList<PatientDTO> GetAllPatients(IPatientDTO Patient,DbEnum source)
{
try
{
PatientsDTO = GetPatientsService.GetPatientsRedis(source, Patient);
}
catch (Exception ex)
{
throw ex;
}
return patientsDTO;
}
internal ParamTypeEnum ByteArrayProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.LongBlob_MySQL);
case DbEnum.SQLServer:
return(ParamTypeEnum.Image_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum TinyText(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.TinyText_MySQL);
case DbEnum.SQLServer:
return(ParamTypeEnum.None);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum DoubleProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.Double_MySQL);
case DbEnum.SQLServer:
return(ParamTypeEnum.Float_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum UlongProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.BigInt_MySQL_SqlServer);
case DbEnum.SQLServer:
return(ParamTypeEnum.Decimal_MySQL_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum GuidProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.Char_MySQL_SqlServer);
case DbEnum.SQLServer:
return(ParamTypeEnum.UniqueIdentifier_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum Table(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.None);
case DbEnum.SQLServer:
return(ParamTypeEnum.Table_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum DateTimeProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.DateTime_MySQL_SqlServer);
case DbEnum.SQLServer:
return(ParamTypeEnum.DateTime2_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum Sql_Variant(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.None);
case DbEnum.SQLServer:
return(ParamTypeEnum.Sql_Variant_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum SmallDateTime(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.None);
case DbEnum.SQLServer:
return(ParamTypeEnum.SmallDateTime_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum Blob(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.Blob_MySQL);
case DbEnum.SQLServer:
return(ParamTypeEnum.None);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum StringProc(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.LongText_MySQL);
case DbEnum.SQLServer:
return(ParamTypeEnum.NVarChar_SqlServer);
default:
return(ParamTypeEnum.None);
}
}
internal ParamTypeEnum MediumInt(DbEnum db)
{
switch (db)
{
case DbEnum.MySQL:
return(ParamTypeEnum.MediumInt_MySQL);
case DbEnum.SQLServer:
return(ParamTypeEnum.None);
default:
return(ParamTypeEnum.None);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connStr">连接串</param>
/// <param name="dbEnum">数据库类型</param>
public DbHelper(string connStr, DbEnum dbEnum = DbEnum.MsSql) {
switch (dbEnum) {
case DbEnum.MsSql:
Connection = new SqlConnection(connStr);
SqlSpecialChar = "@";
break;
case DbEnum.MySql:
MySqlConnection = new MySqlConnection(connStr);
SqlSpecialChar = "?";
break;
default:
Connection = new SqlConnection(connStr);
break;
}
}
public DbInfo CreateDbInfo(DbEnum dbType)
{
switch (dbType)
{
case DbEnum.File:
return(GetFileInfo());
case DbEnum.Queue:
return(GetQueueInfo());
case DbEnum.EnvironmentVariables:
return(GetEnvironmentInfo());
default:
return(null);
}
}
private static void Execute(DTE dte, DbEnum db, string connection, TaskEnum task, string version)
{
var project = GetSelectedProject(dte);
if (project == null)
{
return;
}
BuildProject(dte, project);
var assembly = GetProjectAssemblyPath(project);
var migrate = GetMigratePath(project);
var taskArgument = GetTask(task);
var versionArgument = GetVersion(version);
Process.Start("cmd.exe", $@"/k """"{migrate}"" -c=""{connection}"" -db={db} --task:{taskArgument} {versionArgument} -target=""{assembly}""");
}
/// <summary>トランザクション開始</summary>
/// <param name="iso">分離レベル（Oracleに同じ）</param>
public override void BeginTransaction(DbEnum.IsolationLevelEnum iso)
{
// 分離レベル設定のチェック
if (iso == DbEnum.IsolationLevelEnum.NoTransaction)
{
// トランザクションを開始しない（nullのまま）。
}
else if (iso == DbEnum.IsolationLevelEnum.DefaultTransaction)
{
// 規定の分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction();
}
else if (iso == DbEnum.IsolationLevelEnum.ReadUncommitted)
{
// 無効な分離レベル
throw new ArgumentException(String.Format(
PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_UC, "PostgreSQL"));
}
else if (iso == DbEnum.IsolationLevelEnum.ReadCommitted)
{
// コミット済み読み取りの分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.ReadCommitted);
}
else if (iso == DbEnum.IsolationLevelEnum.RepeatableRead)
{
// 無効な分離レベル
throw new ArgumentException(String.Format(
PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_RR, "PostgreSQL"));
}
else if (iso == DbEnum.IsolationLevelEnum.Serializable)
{
// 直列化可能の分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.Serializable);
}
else if (iso == DbEnum.IsolationLevelEnum.Snapshot)
{
//// スナップショット分離レベルでトランザクションを開始する。
//this._tx = this._cnn.BeginTransaction(IsolationLevel.Snapshot);
// 無効な分離レベル（スナップショット分離レベル）
throw new ArgumentException(String.Format(
PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_SS, "PostgreSQL"));
}
else if (iso == DbEnum.IsolationLevelEnum.User)
{
// 無効な分離レベル（ユーザ指定）。
throw new ArgumentException(PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_USR);
}
else if (iso == DbEnum.IsolationLevelEnum.NotConnect)
{
// 無効な分離レベル（NotConnect指定）。
throw new ArgumentException(PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_NC);
}
else
{
// 通らない予定
}
// 分離レベル（iso）をメンバ変数に保存
_iso = iso;
}
/// <summary>データアクセス制御クラス（ＤＡＭ）の生成し、コネクションを確立、トランザクションを開始する処理を実装</summary>
/// <param name="parameterValue">引数クラス</param>
/// <param name="iso">分離レベル（ＤＢＭＳ毎の分離レベルの違いを理解して設定すること）</param>
/// <remarks>業務コード親クラス１から利用される派生の末端</remarks>
protected override void UOC_ConnectionOpen(
BaseParameterValue parameterValue,
DbEnum.IsolationLevelEnum iso)
{
#region トランザクション属性取得例
//// クラスの属性、メソッドの属性から調査
//MyAttribute[] aryMCA;
//MyAttribute[] aryMMA;
//// クラスの属性を取得
//MyAttribute.GetAttr(this, out aryMCA);
//foreach (MyAttribute mca in aryMCA)
//{
// Debug.WriteLine(this.GetType().ToString() + ".MyAttributeA = " + mca.MyAttributeA);
// Debug.WriteLine(this.GetType().ToString() + ".MyAttributeB = " + mca.MyAttributeB);
// Debug.WriteLine(this.GetType().ToString() + ".MyAttributeC = " + mca.MyAttributeC);
// Debug.WriteLine("+------------------+");
//}
//// メソッドの属性を取得
//MethodInfo[] aryMtdInfo = this.GetType().GetMethods();
//foreach (MethodInfo mtdInfo in aryMtdInfo)
//{
// MyAttribute.GetAttr(mtdInfo, out aryMMA);
// foreach (MyAttribute mma in aryMMA)
// {
// Debug.WriteLine(mtdInfo.Name + ".MyAttributeA = " + mma.MyAttributeA);
// Debug.WriteLine(mtdInfo.Name + ".MyAttributeB = " + mma.MyAttributeB);
// Debug.WriteLine(mtdInfo.Name + ".MyAttributeC = " + mma.MyAttributeC);
// Debug.WriteLine("+------------------+");
// }
//}
#endregion
// データアクセス制御クラス（ＤＡＭ）
BaseDam dam = null;
#region 接続
if (iso == DbEnum.IsolationLevelEnum.NotConnect)
{
// 接続しない
}
else
{
// 接続する
string connstring = "";
#region データ プロバイダ選択
// SQL Server / SQL Client用のDamを生成
dam = new DamSqlSvr();
// 接続文字列をロード
connstring = GetConfigParameter.GetConnectionString("ConnectionString_SQL");
//if (parameterValue.ActionType.Split('%')[0] == "SQL")
//{
// // SQL Server / SQL Client用のDamを生成
// dam = new DamSqlSvr();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_SQL");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "OLE")
//{
// // OLEDB.NET用のDamを生成
// dam = new DamOLEDB();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_OLE");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "ODB")
//{
// // ODBC.NET用のDamを生成
// dam = new DamODBC();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_ODBC");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "ORA")
//{
// // Oracle / Oracle Client用のDamを生成
// dam = new DamOraClient();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_ORA");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "ODP")
//{
// // Oracle / ODP.NET用のDamを生成
// dam = new DamOraOdp();
// // 接続文字列をロード（ODP2：Instant Client）
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_ODP2");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "DB2")
//{
// // DB2.NET用のDamを生成
// dam = new DamDB2();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_DB2");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "HIR")
//{
// // HiRDBデータプロバイダ用のDamを生成
// dam = new DamHiRDB();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_HIR");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "MCN")
//{
// // MySQL Cnn/NET用のDamを生成
// dam = new DamMySQL();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_MCN");
//}
//else if (parameterValue.ActionType.Split('%')[0] == "NPS")
//{
// // PostgreSQL / Npgsql用のDamを生成
// dam = new DamPstGrS();
// // 接続文字列をロード
// connstring = GetConfigParameter.GetConnectionString("ConnectionString_NPS");
//}
//else
//{
// // ここは通らない
//}
#endregion
if (dam != null)
{
// コネクションをオープンする。
dam.ConnectionOpen(connstring);
#region トランザクションを開始する。
if (iso == DbEnum.IsolationLevelEnum.User)
{
// 自動トランザクション（規定の分離レベル）
dam.BeginTransaction(DbEnum.IsolationLevelEnum.ReadCommitted);
}
else
{
// 自動トランザクション（指定の分離レベル）
dam.BeginTransaction(iso);
}
#endregion
// ユーザ情報を格納する（ログ出力で利用）。
dam.Obj = ((MyParameterValue)parameterValue).User;
// damを設定する。
this.SetDam(dam);
}
}
#endregion
}
/// <summary>トランザクション開始</summary> /// <param name="iso">分離レベル</param> /// <remarks>派生のDamXXXでオーバーライドする。</remarks> public abstract void BeginTransaction(DbEnum.IsolationLevelEnum iso);
/// <summary>トランザクション開始</summary>
/// <param name="iso">分離レベル（内部プロバイダによるので全てサポート）</param>
public override void BeginTransaction(DbEnum.IsolationLevelEnum iso)
{
// 分離レベル設定のチェック
if (iso == DbEnum.IsolationLevelEnum.NoTransaction)
{
// トランザクションを開始しない（nullのまま）。
}
else if (iso == DbEnum.IsolationLevelEnum.DefaultTransaction)
{
// 規定の分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction();
}
else if (iso == DbEnum.IsolationLevelEnum.ReadUncommitted)
{
// 非コミット読み取りの分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.ReadUncommitted);
}
else if (iso == DbEnum.IsolationLevelEnum.ReadCommitted)
{
// コミット済み読み取りの分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.ReadCommitted);
}
else if (iso == DbEnum.IsolationLevelEnum.RepeatableRead)
{
// 反復可能読み取りの分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.RepeatableRead);
}
else if (iso == DbEnum.IsolationLevelEnum.Serializable)
{
// 直列化可能の分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.Serializable);
}
else if (iso == DbEnum.IsolationLevelEnum.Snapshot)
{
// スナップショット分離レベルでトランザクションを開始する。
this._tx = this._cnn.BeginTransaction(IsolationLevel.Snapshot);
}
else if (iso == DbEnum.IsolationLevelEnum.User)
{
// 無効な分離レベル（ユーザ指定）。
throw new ArgumentException(
PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_USR);
}
else if (iso == DbEnum.IsolationLevelEnum.NotConnect)
{
// 2009/03/29 -- 追加したNotConnectの対応（このコードブロック）。
// 無効な分離レベル（NotConnect指定）。
throw new ArgumentException(
PublicExceptionMessage.DB_ISO_LEVEL_PARAM_ERROR_NC);
}
else
{
// 通らない予定
}
// 分離レベル（iso）をメンバ変数に保存
_iso = iso;
}
/// <summary>トランザクション制御情報を取得する。</summary>
/// <param name="TransactionPatternID">トランザクション パターンID</param>
/// <param name="connectionString">接続文字列（out）</param>
/// <param name="isolevel">分離レベル（out）</param>
private void GetTCInfo(string TransactionPatternID,
out string connectionString, out DbEnum.IsolationLevelEnum isolevel)
{
connectionString = "";
isolevel = DbEnum.IsolationLevelEnum.NotConnect;
// 属性チェック用
XmlNode xmlNode = null;
// TransactionPatternタグを取得する。
XmlElement xmlElement = this.XMLTCD.GetElementById(TransactionPatternID);
if (xmlElement == null)
{
// TransactionPatternタグがない場合
// 例外を発生させる。
throw new FrameworkException(
FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR[0],
String.Format(FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR[1],
String.Format(FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR_tp, TransactionPatternID)));
}
else
{
// TransactionPatternタグがある場合
// connkey属性
xmlNode = xmlElement.Attributes[FxLiteral.XML_TX_ATTR_CONNKEY];
if (xmlNode == null)
{
// connkey属性なしの場合
}
else
{
// connkey属性ありの場合
connectionString = GetConfigParameter.GetConnectionString(xmlNode.Value);
}
// isolevel属性
xmlNode = xmlElement.Attributes[FxLiteral.XML_TX_ATTR_ISOLEVEL];
if (xmlNode == null)
{
// isolevel属性なしの場合
// 例外を発生させる。
throw new FrameworkException(
FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR[0],
String.Format(FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR[1],
String.Format(FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR_iso1, TransactionPatternID)));
}
else
{
// isolevel属性ありの場合
// 分離level
string isolevelString = xmlNode.Value;
switch (isolevelString.ToUpper())
{
case FxLiteral.ISO_LEVEL_NOT_CONNECT:
isolevel = DbEnum.IsolationLevelEnum.NotConnect;
break;
case FxLiteral.ISO_LEVEL_NO_TRANSACTION:
isolevel = DbEnum.IsolationLevelEnum.NoTransaction;
break;
case FxLiteral.ISO_LEVEL_READ_UNCOMMITTED:
isolevel = DbEnum.IsolationLevelEnum.ReadUncommitted;
break;
case FxLiteral.ISO_LEVEL_READ_COMMIT:
isolevel = DbEnum.IsolationLevelEnum.ReadCommitted;
break;
case FxLiteral.ISO_LEVEL_REPEATABLE_READ:
isolevel = DbEnum.IsolationLevelEnum.RepeatableRead;
break;
case FxLiteral.ISO_LEVEL_SERIALIZABLE:
isolevel = DbEnum.IsolationLevelEnum.Serializable;
break;
case FxLiteral.ISO_LEVEL_SNAPSHOT:
isolevel = DbEnum.IsolationLevelEnum.Snapshot;
break;
case FxLiteral.ISO_LEVEL_DEFAULT:
isolevel = DbEnum.IsolationLevelEnum.DefaultTransaction;
break;
default:
// 定義（分離level）が間違っている。
// 例外を発生させる。
throw new FrameworkException(
FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR[0],
String.Format(FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR[1],
String.Format(FrameworkExceptionMessage.TRANSACTION_CONTROL_XML_FORMAT_ERROR_iso2,
isolevelString, TransactionPatternID)));
}
}
}
}
public async Task <T> SingleOrDefaultOrderByAsync(System.Linq.Expressions.Expression <Func <T, bool> > whereCondition, System.Linq.Expressions.Expression <Func <T, int> > orderBy, DbEnum direction)
{
switch (direction)
{
case DbEnum.ASC:
return(await DbSet.Where(whereCondition).OrderBy(orderBy).FirstOrDefaultAsync());
case DbEnum.DESC:
return(await DbSet.Where(whereCondition).OrderByDescending(orderBy).FirstOrDefaultAsync());
default:
return(await DbSet.Where(whereCondition).OrderBy(orderBy).FirstOrDefaultAsync());
}
}
/// <summary>コンストラクタ</summary>
/// <param name="dbms">DBMSの種類</param>
public SQLUtility(DbEnum.DBMSType dbms)
: this(dbms, "", "") { }
/// <summary>
/// 業務コード呼び出しメソッド（業務ロジックの入り口）
/// </summary>
/// <param name="parameterValue">引数クラス</param>
/// <param name="iso">分離レベル（ＤＢＭＳ毎の分離レベルの違いを理解して設定すること）</param>
/// <returns>戻り値クラス</returns>
/// <remarks>
/// クライアント側（2層C/S）用
/// 画面コード クラスから利用する。
/// </remarks>
public BaseReturnValue DoBusinessLogic(
BaseParameterValue parameterValue, DbEnum.IsolationLevelEnum iso)
{
// 戻り値クラス
BaseReturnValue returnValue = null;
// オリジナルのスタックトレース値のクリア
this.OriginalStackTrace = "";
// データアクセス制御クラス（ＤＡＭ）がグローバルなので、全てロックする。
lock (BaseLogic2CS._lock)
{
if (BaseLogic2CS._dam == null)
{
// データアクセス制御クラス（ＤＡＭ）が無い場合
// ★データアクセス制御クラス（ＤＡＭ）の生成し、コネクションを確立、
// トランザクションを開始する処理（業務フレームワークに、UOCで実装する）
this.UOC_ConnectionOpen(parameterValue, iso);
}
else
{
// データアクセス制御クラス（ＤＡＭ）が有る場合
}
try
{
// 自動振り分け対応
this.WasCalledFromDoBusinessLogic = true;
// ★前処理（業務フレームワークに、UOCで実装する）
this.UOC_PreAction(parameterValue);
// ★業務ロジックの実行（業務処理の派生クラスに、UOCで実装する）
this.UOC_DoAction(parameterValue, ref returnValue);
// ★後処理（業務フレームワークに、UOCで実装する）
this.UOC_AfterAction(parameterValue, returnValue);
//// トランザクション終了
//BaseLogic2CS._dam.CommitTransaction();
//// ★トランザクション完了後の後処理（業務フレームワークに、UOCで実装する）
//this.UOC_AfterTransaction(parameterValue, returnValue);
}
catch (BusinessApplicationException baEx)// 業務例外
{
// ★★業務例外時のロールバックは自動にしない。
// 業務例外の場合、エラーフラグをセットする。
// 戻り値がnullの場合は、生成する。
if (returnValue == null)
{
returnValue = new BaseReturnValue();
}
returnValue.ErrorFlag = true;
// メッセージを戻す（戻り値クラスに設定）。
returnValue.ErrorMessageID = baEx.messageID;
returnValue.ErrorMessage = baEx.Message;
returnValue.ErrorInfo = baEx.Information;
// ★異常系の後処理（業務フレームワークに、UOCで実装する）
this.UOC_ABEND(parameterValue, returnValue, baEx);
// 正常系の戻り値にして戻すため、リスローしない。
}
catch (BusinessSystemException bsEx)// システム例外
{
// ★システム例外時は、自動的にロールバック。
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
// トランザクションをロールバック
if (BaseLogic2CS._dam == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// 例外対策（例外は潰さない）
try
{
// nullでない場合はロールバックする。
BaseLogic2CS._dam.RollbackTransaction();
// コネクション クローズ
BaseLogic2CS._dam.ConnectionClose();
}
finally
{
// nullクリア（次回、再接続される。）
BaseLogic2CS._dam = null;
}
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 戻り値がnullの場合は、生成する。
if (returnValue == null)
{
returnValue = new BaseReturnValue();
}
// ★異常系の後処理（業務フレームワークに、UOCで実装する）
this.UOC_ABEND(parameterValue, returnValue, bsEx);
// リスロー
throw;
}
catch (Exception Ex)// その他、一般的な例外
{
// ★その他、一般的な例外は、自動的にロールバック。
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
// トランザクションをロールバック
if (BaseLogic2CS._dam == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// 例外対策（例外は潰さない）
try
{
// nullでない場合はロールバックする。
BaseLogic2CS._dam.RollbackTransaction();
// コネクション クローズ
BaseLogic2CS._dam.ConnectionClose();
}
finally
{
// nullクリア（次回、再接続される。）
BaseLogic2CS._dam = null;
}
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 戻り値がnullの場合は、生成する。
if (returnValue == null)
{
returnValue = new BaseReturnValue();
}
// ★異常系の後処理（業務フレームワークに、UOCで実装する）
this.UOC_ABEND(parameterValue, ref returnValue, Ex);
// リスローしない（上記のUOC_ABENDで必要に応じてリスロー）
// throw;
}
finally
{
// 自動振り分け対応
this.WasCalledFromDoBusinessLogic = false;
// クライアント側（2層C/S）用では、マニュアル操作だが、
// ノートランザクションの時は、都度コネクションを閉じる。
// Damオブジェクトの存在チェック
if (BaseLogic2CS._dam == null)
{
// nullのためなにもしない。
}
else
{
// ノートランザクションの時は、都度コネクションを閉じる。
if (iso == DbEnum.IsolationLevelEnum.NoTransaction)
{
// 例外対策（例外は潰さない）
try
{
// コネクション クローズ
BaseLogic2CS._dam.ConnectionClose();
}
finally
{
// nullクリア（次回の「DoBusinessLogic_2CS」で再接続される。）
BaseLogic2CS._dam = null;
}
}
}
}
}
// 戻り値を戻す。
return returnValue;
}
/// <summary>コンストラクタ</summary>
/// <param name="dbms">DBMSの種類</param>
/// <param name="convertString">文字列変換方法（空の場合は既定値を使用）</param>
/// <param name="dateTimeFormatString">日付を文字列化する際に使用するFormatString</param>
public SQLUtility(DbEnum.DBMSType dbms, string convertString, string dateTimeFormatString)
{
this._dbms = dbms;
switch (this._dbms)
{
case DbEnum.DBMSType.SQLServer:
// convertString
if (string.IsNullOrEmpty(convertString))
{
// 既定値
this._convertString = "nvarchar";
}
else
{
// 指定の値
this._convertString = convertString;
}
// dateTimeFormatString
if (string.IsNullOrEmpty(dateTimeFormatString))
{
// 既定値
this._dateTimeFormatString = "yyyy/MM/dd HH:mm:ss.fff";
}
else
{
// 指定の値
this._dateTimeFormatString = dateTimeFormatString;
}
break;
case DbEnum.DBMSType.PstGrS:
// convertString
if (string.IsNullOrEmpty(convertString))
{
// 既定値
this._convertString = "text";
}
else
{
// 指定の値
this._convertString = convertString;
}
// dateTimeFormatString
if (string.IsNullOrEmpty(dateTimeFormatString))
{
// 既定値
this._dateTimeFormatString = "yyyy/MM/dd HH:mm:ss.fff";
}
else
{
// 指定の値
this._dateTimeFormatString = dateTimeFormatString;
}
break;
case DbEnum.DBMSType.Oracle:
// convertString
if (string.IsNullOrEmpty(convertString))
{
// 既定値
this._convertString = "varchar2";
}
else
{
// 指定の値
this._convertString = convertString;
}
// dateTimeFormatString
if (string.IsNullOrEmpty(dateTimeFormatString))
{
// 既定値
this._dateTimeFormatString = "dd-MMM-yyyy hh:mm:ss tt";
}
else
{
// 指定の値
this._dateTimeFormatString = dateTimeFormatString;
}
break;
case DbEnum.DBMSType.MySQL:
// convertString
if (string.IsNullOrEmpty(convertString))
{
// 既定値
this._convertString = "char";
}
else
{
// 指定の値
this._convertString = convertString;
}
// dateTimeFormatString
if (string.IsNullOrEmpty(dateTimeFormatString))
{
// 既定値
this._dateTimeFormatString = "yyyy/MM/dd HH:mm:ss.fff";
}
else
{
// 指定の値
this._dateTimeFormatString = dateTimeFormatString;
}
break;
case DbEnum.DBMSType.DB2:
// convertString
if (string.IsNullOrEmpty(convertString))
{
// 既定値
this._convertString = "varchar";
}
else
{
// 指定の値
this._convertString = convertString;
}
// dateTimeFormatString
if (string.IsNullOrEmpty(dateTimeFormatString))
{
// 既定値
this._dateTimeFormatString = "yyyy-MM-dd-HH.mm.ss.fff";
}
else
{
// 指定の値
this._dateTimeFormatString = dateTimeFormatString;
}
break;
default:
throw new NotImplementedException(PublicExceptionMessage.NOT_IMPLEMENTED);
}
}
/// <summary>コンストラクタ</summary>
/// <param name="dbms">DBMSの種類</param>
/// <param name="convertString">文字列変換方法（空の場合は既定値を使用）</param>
public SQLUtility(DbEnum.DBMSType dbms, string convertString)
: this(dbms, convertString, "") { }
/// <summary>
/// 業務コード呼び出しメソッド（業務ロジックの入り口）
/// </summary>
/// <param name="parameterValue">引数クラス</param>
/// <param name="iso">分離レベル（ＤＢＭＳ毎の分離レベルの違いを理解して設定すること）</param>
/// <returns>戻り値クラス</returns>
/// <remarks>画面コード クラスから利用する。</remarks>
public BaseReturnValue DoBusinessLogic(
BaseParameterValue parameterValue, DbEnum.IsolationLevelEnum iso)
{
// 戻り値クラス
BaseReturnValue returnValue = null;
// オリジナルのスタックトレース値のクリア
this.OriginalStackTrace = "";
// ★データアクセス制御クラス（ＤＡＭ）の生成し、コネクションを確立、
// トランザクションを開始する処理（業務フレームワークに、UOCで実装する）
// this._dam = this.UOC_ConnectionOpen(parameterValue, iso);
this.UOC_ConnectionOpen(parameterValue, iso);
try
{
// 自動振り分け対応
this.WasCalledFromDoBusinessLogic = true;
// ★前処理（業務フレームワークに、UOCで実装する）
this.UOC_PreAction(parameterValue);
// ★業務ロジックの実行（業務処理の派生クラスに、UOCで実装する）
this.UOC_DoAction(parameterValue, ref returnValue);
// ★後処理（業務フレームワークに、UOCで実装する）
this.UOC_AfterAction(parameterValue, returnValue);
#region トランザクションをコミット
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
if (this._dam == null)
{
// nullの場合はコミットしない（何もしない）。
}
else
{
// nullでない場合はコミットする。
this._dam.CommitTransaction();
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 2009/03/28---データアクセス制御クラスを配列化（ここから）
foreach (string key in this._dams.Keys)
{
// ここはforeachで取るので「キーなし」にならない
if (this._dams[key] == null)
{
// nullの場合はコミットしない（何もしない）。
}
else
{
// nullでない場合はコミットする。
((BaseDam)this._dams[key]).CommitTransaction();
}
}
// 2009/03/28---データアクセス制御クラスを配列化（ここまで）
#endregion
// ★トランザクション完了後の後処理（業務フレームワークに、UOCで実装する）
this.UOC_AfterTransaction(parameterValue, returnValue);
}
catch (BusinessApplicationException baEx)// 業務例外
{
#region トランザクションをロールバック
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
if (this._dam == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// nullでない場合はロールバックする。
this._dam.RollbackTransaction();
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 2009/03/28---データアクセス制御クラスを配列化（ここから）
foreach (string key in this._dams.Keys)
{
// ここはforeachで取るので「キーなし」にならない
if (this._dams[key] == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// nullでない場合はロールバックする。
((BaseDam)this._dams[key]).RollbackTransaction();
}
}
// 2009/03/28---データアクセス制御クラスを配列化（ここまで）
#endregion
// 業務例外の場合、エラーフラグをセットする。
// 戻り値がnullの場合は、生成する。
if (returnValue == null)
{
returnValue = new BaseReturnValue();
}
returnValue.ErrorFlag = true;
// メッセージを戻す（戻り値クラスに設定）。
returnValue.ErrorMessageID = baEx.messageID;
returnValue.ErrorMessage = baEx.Message;
returnValue.ErrorInfo = baEx.Information;
// ★異常系の後処理（業務フレームワークに、UOCで実装する）
this.UOC_ABEND(parameterValue, returnValue, baEx);
// 正常系の戻り値にして戻すため、リスローしない。
}
catch (BusinessSystemException bsEx)// システム例外
{
#region トランザクションをロールバック
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
if (this._dam == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// nullでない場合はロールバックする。
this._dam.RollbackTransaction();
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 2009/03/28---データアクセス制御クラスを配列化（ここから）
foreach (string key in this._dams.Keys)
{
// ここはforeachで取るので「キーなし」にならない
if (this._dams[key] == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// nullでない場合はロールバックする。
((BaseDam)this._dams[key]).RollbackTransaction();
}
}
// 2009/03/28---データアクセス制御クラスを配列化（ここまで）
#endregion
// 戻り値がnullの場合は、生成する。
if (returnValue == null)
{
returnValue = new BaseReturnValue();
}
// ★異常系の後処理（業務フレームワークに、UOCで実装する）
this.UOC_ABEND(parameterValue, returnValue, bsEx);
// リスロー
throw;
}
catch (Exception Ex)// その他、一般的な例外
{
#region トランザクションをロールバック
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
if (this._dam == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// nullでない場合はロールバックする。
this._dam.RollbackTransaction();
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 2009/03/28---データアクセス制御クラスを配列化（ここから）
foreach (string key in this._dams.Keys)
{
// ここはforeachで取るので「キーなし」にならない
if (this._dams[key] == null)
{
// nullの場合はロールバックしない（何もしない）。
}
else
{
// nullでない場合はロールバックする。
((BaseDam)this._dams[key]).RollbackTransaction();
}
}
// 2009/03/28---データアクセス制御クラスを配列化（ここまで）
#endregion
// 戻り値がnullの場合は、生成する。
if (returnValue == null)
{
returnValue = new BaseReturnValue();
}
// ★異常系の後処理（業務フレームワークに、UOCで実装する）
this.UOC_ABEND(parameterValue, ref returnValue, Ex);
// リスローしない（上記のUOC_ABENDで必要に応じてリスロー）
// throw;
}
finally
{
// 自動振り分け対応
this.WasCalledFromDoBusinessLogic = false;
#region コネクションを閉じる
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここから）
if (this._dam == null)
{
// nullのためなにもしない。
}
else
{
// コネクションを閉じる。
this._dam.ConnectionClose();
}
// 2009/03/13---Ｂ層内：トランザクション手動制御を可能に（ここまで）
// 2009/03/28---データアクセス制御クラスを配列化（ここから）
foreach (string key in this._dams.Keys)
{
// ここはforeachで取るので「キーなし」にならない
if (this._dams[key] == null)
{
// nullのためなにもしない。
}
else
{
// コネクションを閉じる。
((BaseDam)this._dams[key]).ConnectionClose();
}
}
// 2009/03/28---データアクセス制御クラスを配列化（ここまで）
#endregion
}
// 戻り値を戻す。
return returnValue;
}
// 2009/03/28---データアクセス制御クラスを配列化（ここまで）
#endregion
#region 業務コード親クラス２でオーバーライドするメソッド
/// <summary>
/// データアクセス制御クラス（ＤＡＭ）の生成し、
/// コネクションを確立、トランザクションを開始する処理を実装
/// </summary>
/// <param name="parameterValue">引数クラス</param>
/// <param name="iso">分離レベル（ＤＢＭＳ毎の分離レベルの違いを理解して設定すること）</param>
/// <remarks>派生の業務コード親クラス２でオーバーライドする。</remarks>
protected virtual void UOC_ConnectionOpen(
BaseParameterValue parameterValue,
DbEnum.IsolationLevelEnum iso) { return; }
public DbConnectionService(DbEnum dbType)
{
var builder = new ConnectionBuilder();
_conn = builder.BuildConnection(dbType);
}
public DbResult(T data, DbEnum status)
{
this.Data = data;
this.Status = status;
}
private DbConfigService(DbEnum dbType)
{
DbType = dbType;
}
