/// <summary>
/// Creates a new transaction scope associated with the specified connection,
/// using the specified transaction configuration options.
/// The scope can be nested inside another scope in which case the underlying
/// db transaction is only committed once both the outer and inner transaction(s)
/// have been committed. The returned ITransactionScope implements IDisposable
/// and should be wrapped in a using statement.
/// </summary>
/// <param name="dbConnection">
/// <para>
/// The DbConnection instance to manage transactions for. Transaction scopes
/// created by this instance only apply to a single DbConnection, so if you want
/// the scope to span additional data access mechanism then they must share the
/// same connection.
/// </para>
/// <para>
/// You can use the ICofoundryDbConnectionManager to get a reference to the shared
/// connection directly.
/// </para>
/// </param>
/// <param name="transactionScopeOption">This is defaulted to TransactionScopeOption.Required.</param>
/// <param name="isolationLevel">This is defaulted to IsolationLevel.ReadCommitted.</param>
/// <returns>ITransactionScope, which is IDisposable and must be disposed.</returns>
public ITransactionScope Create(DbConnection dbConnection,
System.Transactions.TransactionScopeOption transactionScopeOption = System.Transactions.TransactionScopeOption.Required,
System.Transactions.IsolationLevel isolationLevel = System.Transactions.IsolationLevel.ReadCommitted
)
{
var transactionScopeFactory = CreateScopeFactory(transactionScopeOption, isolationLevel);
return(Create(dbConnection, transactionScopeFactory));
}
public RawSQLEntityFramework(DbContext context, Transactions.IsolationLevel isoLevel = Transactions.IsolationLevel.ReadCommitted, Transactions.TransactionScopeOption scopeOption = Transactions.TransactionScopeOption.RequiresNew)
{
ContractUtility.Requires <ArgumentNullException>(context.IsNotNull(), "context instance cannot be null");
_context = context;
//_context.Database.CreateIfNotExists();//Alongwith creating the DB(if the DB does not exist),
// this method also creates the tables even if the tables do not exist - also alters the tables if
// some changes are there in the structure of domain classes.
_isoLevel = isoLevel;
_scopeOption = scopeOption;
}
private Func <System.Transactions.TransactionScope> CreateScopeFactory(
System.Transactions.TransactionScopeOption transactionScopeOption = System.Transactions.TransactionScopeOption.Required,
System.Transactions.IsolationLevel isolationLevel = System.Transactions.IsolationLevel.ReadCommitted
)
{
return(() => _transactionScopeFactory.Create(
transactionScopeOption,
isolationLevel
));
}
public static sysTx.TransactionScope Make(
sysTx.TransactionScopeOption txScopOption = sysTx.TransactionScopeOption.Required,
sysTx.IsolationLevel isoLevel = sysTx.IsolationLevel.ReadCommitted,
double timeOutMinutes = 30d, sysTx.DependentTransaction depTx = null)
{
return(depTx != null?
new sysTx.TransactionScope(depTx):
new sysTx.TransactionScope(txScopOption,
new sysTx.TransactionOptions {
IsolationLevel = isoLevel,
Timeout = TimeSpan.FromMinutes(timeOutMinutes)
}));
}
public void Execute <C>(C context) where C : PipelineContext
{
PropertyInfo[] properties = PipelineEvent.GetType().GetProperties();
List <PropertyInfo> sortedProperties = properties.ToList <PropertyInfo>();
sortedProperties.Sort(new PropertyComparer());
System.Transactions.TransactionScopeOption pipelineScopeOption = TransactionRequirement(sortedProperties);
using (TransactionScope pipelineScope = new TransactionScope(pipelineScopeOption))
{
sortedProperties.ForEach(property =>
{
object[] attributes =
property.GetCustomAttributes(typeof(PipelineEventAttribute), true);
if (attributes.Length > 0)
{
PipelineEventAttribute attr = (PipelineEventAttribute)attributes[0];
System.Transactions.TransactionScopeOption scopeOption =
GetTransactionScopeOption(attr.TransactionScopeOption);
object value = property.GetValue(PipelineEvent, null);
Action <C> eventProp = (Action <C>)value;
if (eventProp != null)
{
using (TransactionScope eventScope = new TransactionScope(scopeOption))
{
if (eventProp != null)
{
eventProp(context);
if (context.Cancel == true)
{
throw new Exception(property.Name + " failed.");
}
}
eventScope.Complete();
}
}
}
});
pipelineScope.Complete();
}
}
private System.Transactions.TransactionScopeOption GetTransactionScopeOption(TransactionScopeOption transactionScopeOption)
{
System.Transactions.TransactionScopeOption scopeOption = System.Transactions.TransactionScopeOption.Required;
if (transactionScopeOption == TransactionScopeOption.RequiredNew)
{
scopeOption = System.Transactions.TransactionScopeOption.RequiresNew;
}
else if (transactionScopeOption == TransactionScopeOption.Suppress)
{
scopeOption = System.Transactions.TransactionScopeOption.Suppress;
}
return(scopeOption);
}
public void Execute(PipelineContext <TContext> pipelineEvent, TContext context, TransactionScopeOption transactionScope)
{
Contract.Requires(pipelineEvent != null);
Contract.Requires(context != null);
Definition.Pipeline pipeline = GetPipelineDefinition();
System.Transactions.TransactionScopeOption scopeOption =
GetTransactionScopeOption(transactionScope);
if (pipelineEvent != null)
{
using (TransactionScope eventScope = new TransactionScope(scopeOption))
{
PipelineEventFiringEventArgs args =
new PipelineEventFiringEventArgs(pipeline.Name);
OnPipelineEventFiring(args);
if (!args.Cancel)
{
if (pipeline.InvokeAll)
{
if (pipelineEvent != null)
{
pipelineEvent(context);
}
}
else
{
Delegate[] list = pipelineEvent.GetInvocationList();
foreach (PipelineContext <TContext> item in list)
{
item(context);
if (context.Cancel)
{
break;
}
}
}
OnPipelineEventFired(new PipelineEventFiredEventArgs(pipeline.Name));
}
eventScope.Complete();
}
}
}
private System.Transactions.TransactionScopeOption TransactionRequirement(List <PropertyInfo> sortedProperties)
{
System.Transactions.TransactionScopeOption pipelineScopeOption = System.Transactions.TransactionScopeOption.Suppress;
foreach (PropertyInfo property in sortedProperties)
{
object[] attributes = property.GetCustomAttributes(typeof(PipelineEventAttribute), true);
if (attributes.Length > 0)
{
PipelineEventAttribute attr = (PipelineEventAttribute)attributes[0];
if (attr.TransactionScopeOption != TransactionScopeOption.Suppress)
{
pipelineScopeOption = System.Transactions.TransactionScopeOption.Required;
break;
}
}
}
return(pipelineScopeOption);
}
public void Execute(TEvents pipelineEvents, TContext context)
{
Contract.Requires(pipelineEvents != null);
Contract.Requires(context != null);
Definition.Pipeline pipeline = GetPipelineDefinition();
PropertyInfo[] properties = pipelineEvents.GetType().GetProperties();
List <PropertyInfo> sortedProperties = properties.ToList <PropertyInfo>();
sortedProperties.Sort(new PropertyComparer());
System.Transactions.TransactionScopeOption pipelineScopeOption = TransactionRequirement(sortedProperties);
using (TransactionScope pipelineScope = new TransactionScope(pipelineScopeOption))
{
sortedProperties.ForEach(property =>
{
object[] attributes =
property.GetCustomAttributes(typeof(PipelineEventAttribute), true);
if (attributes.Length > 0)
{
PipelineEventAttribute attr = (PipelineEventAttribute)attributes[0];
System.Transactions.TransactionScopeOption scopeOption =
GetTransactionScopeOption(attr.TransactionScopeOption);
object value = property.GetValue(pipelineEvents, null);
PipelineContext <TContext> eventProp = (PipelineContext <TContext>)value;
if (eventProp != null)
{
using (TransactionScope eventScope = new TransactionScope(scopeOption))
{
PipelineEventFiringEventArgs args = new PipelineEventFiringEventArgs(pipeline.Name, property.Name);
OnPipelineEventFiring(args);
if (!args.Cancel)
{
if (pipeline.InvokeAll)
{
if (eventProp != null)
{
eventProp(context);
}
}
else
{
Delegate[] list = eventProp.GetInvocationList();
foreach (PipelineContext <TContext> item in list)
{
item(context);
if (context.Cancel)
{
break;
}
}
}
OnPipelineEventFired(new PipelineEventFiredEventArgs(pipeline.Name, property.Name));
}
eventScope.Complete();
}
}
}
});
pipelineScope.Complete();
}
}
