参考资料：https://www.cnblogs.com/tuousi99/p/4455573.html

 

using System;

using System.Data;

namespace Manjinba.Dynamics.Domain.Interfaces

{

/// <summary>

///

/// </summary>

public interface IBaseDbContext : IDisposable

{

/// <summary>

///

/// </summary>

IDbConnection Reader { get; }

/// <summary>

///

/// </summary>

IDbConnection Writer { get; }

/// <summary>

///

/// </summary>

void InitConnection();

}

}

 

 

using Manjinba.Dynamics.Domain.Interfaces;

using Microsoft.Extensions.Configuration;

using Microsoft.Extensions.Hosting;

using System.Configuration;

using System.Data;

using System.Data.Common;

using Oracle.ManagedDataAccess.Client;

namespace Manjinba.Dynamics.Infrastructure.Data.Context

{

/// <summary>

///

/// </summary>

public class BaseDbContext : DisposableObject, IBaseDbContext

{

#region Fields

private readonly IHostingEnvironment _env;

private readonly ConnectionStringSettings _readerConnectString = null;

private readonly ConnectionStringSettings _writerConnectString = null;

#endregion

#region Properties

public IDbConnection Reader { private set; get; }

public IDbConnection Writer { private set; get; }

#endregion

#region Methods

/// <summary>

///

/// </summary>

/// <param name="env"></param>

public BaseDbContext(IHostingEnvironment env)

{

_env = env;

// get the configuration from the app settings

var config = new ConfigurationBuilder()

.SetBasePath(_env.ContentRootPath)

.AddJsonFile("appsettings.json")

.Build();

// define the database to use

_readerConnectString = new ConnectionStringSettings("DynConnectionString_Reader", config.GetConnectionString("DynConnectionString_Reader"), "Oracle.ManagedDataAccess.Client");

_writerConnectString = new ConnectionStringSettings("DynConnectionString_Writer", config.GetConnectionString("DynConnectionString_Writer"), "Oracle.ManagedDataAccess.Client");

InitConnection();

}

/// <summary>

///

/// </summary>

public void InitConnection()

{

if (Reader == null)

Reader = new OracleConnection(_readerConnectString.ConnectionString);

if (Writer == null)

Writer = new OracleConnection(_writerConnectString.ConnectionString);

//DbProviderFactory dbReaderFactory = DbProviderFactories.GetFactory(this._readerConnectString.ProviderName);

//DbProviderFactory dbWriterFactory = DbProviderFactories.GetFactory(this._writerConnectString.ProviderName);

//this.Reader = dbReaderFactory.CreateConnection();

//this.Reader = dbWriterFactory.CreateConnection();

//if (Reader != null) this.Reader.ConnectionString = this._readerConnectString.ConnectionString;

//if (Writer != null) this.Writer.ConnectionString = this._writerConnectString.ConnectionString;

}

/// <summary>

///

/// </summary>

/// <param name="isDispose"></param>

protected override void Dispose(bool isDispose)

{

if (!isDispose)

{

return;

}

if (this.Writer.State == ConnectionState.Open)

this.Writer.Close();

if (this.Writer.State == ConnectionState.Open)

this.Writer.Dispose();

}

#endregion

}

}

 

 

using Manjinba.Dynamics.Domain.Core.Models;

using System;

using System.Collections.Generic;

using System.Data;

namespace Manjinba.Dynamics.Domain.Interfaces

{

/// <summary>

///

/// </summary>

public interface IUnitOfWork : IDisposable

{

/// <summary>

///

/// </summary>

bool Committed { set; get; }

/// <summary>

/// 数据库执行错误码

/// </summary>

IList<int> ErrorCode { get; set; }

/// <summary>

///

/// </summary>

IDbTransaction Tran { get; }

/// <summary>

///

/// </summary>

/// <param name="entity"></param>

/// <param name="callback"></param>

void RegisterAdd(IEntity entity, Func<int> callback);

/// <summary>

///

/// </summary>

/// <param name="entity"></param>

/// <param name="callback"></param>

void RegisterUpdate(IEntity entity, Func<int> callback);

/// <summary>

///

/// </summary>

/// <param name="entity"></param>

/// <param name="callback"></param>

void RegisterDelete(IEntity entity, Func<int> callback);

/// <summary>

///

/// </summary>

void BeginTran();

/// <summary>

///

/// </summary>

bool Commit();

/// <summary>

///

/// </summary>

void Rollback();

}

}

 

 

using Manjinba.Dynamics.Domain.Core.Models;

using Manjinba.Dynamics.Domain.Interfaces;

using Manjinba.Dynamics.Infrastructure.Data.Context;

using Oracle.ManagedDataAccess.Client;

using System;

using System.Collections.Generic;

using System.Data;

using System.Transactions;

namespace Manjinba.Dynamics.Infrastructure.Data.UoW

{

/// <summary>

///

/// </summary>

public class UnitOfWork : IUnitOfWork

{

#region Fields

private readonly IBaseDbContext _dbContext;

/// <summary>

/// GetRepository方法简单地采用了Dictionary对象来实现缓存仓储实例的效果，当然这种做法还有待改进

/// 懒加载或多线程安全字典

/// </summary>

private Dictionary<Type, object> repositoryCache = new Dictionary<Type, object>();

private Dictionary<IEntity, Func<int>> addEntities;

private Dictionary<IEntity, Func<int>> updateEntities;

private Dictionary<IEntity, Func<int>> deleteEntities;

private bool _committed = true;

private readonly object _sync = new object();

public IDbTransaction Tran { private set; get; }

#endregion

#region Properties

public bool Committed

{

set { _committed = value; }

get { return _committed; }

}

/// <summary>

/// 数据库执行错误码

/// </summary>

public IList<int> ErrorCode { get; set; }

#endregion

#region Methods

/// <summary>

///

/// </summary>

/// <param name="dbContext"></param>

public UnitOfWork(IBaseDbContext dbContext)

{

_dbContext = dbContext;

addEntities = new Dictionary<IEntity, Func<int>>();

updateEntities = new Dictionary<IEntity, Func<int>>();

deleteEntities = new Dictionary<IEntity, Func<int>>();

ErrorCode = new List<int>();

//this.Committed = false;

BeginTran();

}

/// <summary>

///

/// </summary>

/// <param name="entity"></param>

/// <param name="callback"></param>

public void RegisterAdd(IEntity entity, Func<int> callback)

{

addEntities.Add(entity, callback);

}

/// <summary>

///

/// </summary>

/// <param name="entity"></param>

/// <param name="callback"></param>

public void RegisterUpdate(IEntity entity, Func<int> callback)

{

updateEntities.Add(entity, callback);

}

/// <summary>

///

/// </summary>

/// <param name="entity"></param>

/// <param name="callback"></param>

public void RegisterDelete(IEntity entity, Func<int> callback)

{

deleteEntities.Add(entity, callback);

}

/// <summary>

///

/// </summary>

public void BeginTran()

{

_dbContext.Writer.Open();

this.Tran = ((OracleConnection)_dbContext.Writer).BeginTransaction(System.Data.IsolationLevel.ReadCommitted);

this.Committed = false;

}

/// <summary>

///

/// </summary>

public bool Commit()

{

var addCnt = 0;

var updCnt = 0;

var delCnt = 0;

foreach (var entity in addEntities.Keys)

{

var add = addEntities[entity]();

if (add > 0)

addCnt += add;

else

ErrorCode.Add(add);

}

foreach (var entity in updateEntities.Keys)

{

var upd = updateEntities[entity]();

if (upd > 0)

updCnt += upd;

else

ErrorCode.Add(upd);

}

foreach (var entity in deleteEntities.Keys)

{

var del = deleteEntities[entity]();

if (del > 0)

delCnt += del;

else

ErrorCode.Add(del);

}

if (addCnt == addEntities.Count && updCnt == updateEntities.Count && delCnt == deleteEntities.Count)

{

Committed = true;

this.Tran.Commit();

return true;

}

lock (_sync)

{

this.Tran.Rollback();

this._committed = true;

return false;

}

}

/// <summary>

///

/// </summary>

public void Rollback()

{

if (Committed) return;

lock (_sync)

{

this.Tran.Rollback();

this._committed = true;

}

}

/// <summary>

///

/// </summary>

public void Dispose()

{

this.repositoryCache.Clear();

_dbContext.Dispose();

}

#endregion

}

}