public ITransactionObject Reused(IEnumerable <ITransactionObject> existedTrasactions, IDbExecutor dbExecutor)
{
if (existedTrasactions.Count() == 0)
{
return(null);
}
ITransactionObject optimalTransaction = null;
if (dbExecutor is not IEFCoreDbExecutor eFCoreDbExecutor)
{
return(null);
}
//DbContext only can receive DbTransaction.
optimalTransaction = existedTrasactions.FirstOrDefault(s =>
{
/*
* todo:how to reuse same transation.
* .....
*/
return(false);
});
return(optimalTransaction);
}
protected override bool SetTransaction(ITransactionObject transaction)
{
if (transaction.TransactionInstance is int)
{
TransactionObject = transaction;
DbOjectInstance.SetTransaction(transaction.TransactionInstance);
return(true);
}
return(false);
}
protected override Task <bool> SetTransactionAsync(ITransactionObject transaction, CancellationToken cancellationToken)
{
var result = false;
if (transaction.TransactionInstance is int)
{
TransactionObject = transaction;
DbOjectInstance.SetTransaction(transaction.TransactionInstance);
result = true;
}
return(Task.FromResult(result));
}
protected virtual async Task <ITransactionObject> OpenTransactionAndGiveExecutorAsync(
IEnumerable <ITransactionProvider> transactionProviders,
IDbExecutor dbExecutor,
CancellationToken cancellationToken)
{
//if not any provider,reutrn false.
if (transactionProviders.Count() == 0)
{
return(null);
}
ITransactionObject exceptedTransaction = null;
foreach (var transactionProvider in transactionProviders)
{
if (!transactionProvider.CanCreate(dbExecutor))
{
continue;
}
//already has transaction,can reused?
if (CreatedTransactions.Count > 0)
{
var reusedTransaction = transactionProvider.Reused(CreatedTransactions, dbExecutor);
if (reusedTransaction != null)
{
//reused this transaction,and back.
await dbExecutor.UseTransactionAsync(reusedTransaction, cancellationToken);
return(reusedTransaction);
}
}
//create new transaction.
exceptedTransaction = await transactionProvider.GetTransactionObjectAsync(new CreateTransactionContext(this, dbExecutor), cancellationToken);
if (exceptedTransaction != null)
{
await dbExecutor.UseTransactionAsync(exceptedTransaction, cancellationToken);
break;
}
//if exceptedTransaction is null,let the next provider create.
}
return(exceptedTransaction);
}
public ITransactionObject Reused(IEnumerable <ITransactionObject> existedTrasactions, IDbExecutor dbExecutor)
{
if (existedTrasactions.Count() == 0)
{
return(null);
}
ITransactionObject optimalTransaction = null;
IEFCoreDbExecutor eFCoreDbExecutor = dbExecutor as IEFCoreDbExecutor;
if (eFCoreDbExecutor == null)
{
return(null);
}
//DbContext only can receive DbTransaction.
//Todo:If there has more DbTransaction,How to compare?
optimalTransaction = existedTrasactions.FirstOrDefault(s =>
{
if (!s.IsCommit && s.TransactionInstance is DbTransaction dbTransaction)
{
var dbContext = eFCoreDbExecutor.EFCoreDbContext;
//Get EF Core DbConnection.
//Only detail relational transaction.
var relationDatabase = (dbContext.Database as IDatabaseFacadeDependenciesAccessor)?.Dependencies as IRelationalDatabaseFacadeDependencies;
if (relationDatabase == null)
{
return(false);
}
//It's mean they use same database.
#pragma warning disable EF1001 // Internal EF Core API usage.
return(relationDatabase.RelationalConnection.DbConnection.ConnectionString.Equals(dbTransaction.Connection.ConnectionString));
#pragma warning restore EF1001 // Internal EF Core API usage.
}
return(false);
});
return(optimalTransaction);
}
protected override bool SetTransaction(ITransactionObject transaction)
{
CheckValue.NotNull(transaction, nameof(transaction));
bool result = false;;
//Only receive DbTransaction.
if (transaction.TransactionInstance is DbTransaction dbTransaction)
{
try
{
DbOjectInstance.Database.UseTransaction(dbTransaction);
result = true;
}
catch
{
result = false;
}
}
return(result);
}
protected override async Task <bool> SetTransactionAsync(ITransactionObject transaction, CancellationToken cancellationToken)
{
CheckValue.NotNull(transaction, nameof(transaction));
bool result = false;;
//Only receive DbTransaction.
if (transaction.TransactionInstance is DbTransaction dbTransaction)
{
try
{
await DbOjectInstance.Database.UseTransactionAsync(dbTransaction, cancellationToken);
result = true;
}
catch
{
result = false;
}
}
return(result);
}
protected override Task <bool> SetTransactionAsync(ITransactionObject transaction, CancellationToken cancellationToken)
{
var result = SetTransaction(transaction);
return(Task.FromResult(result));
}
protected override Task <bool> SetTransactionAsync(ITransactionObject transaction, CancellationToken cancellationToken)
{
TransactionObject = transaction;
DbOjectInstance.SetTransaction(transaction.TransactionInstance);
return(Task.FromResult(true));
}
