protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { StructuredTracer.Correlate(); try { if (command is SaveWorkflowCommand) { return new TypedCompletedAsyncResult<bool>(SaveWorkflow(context, (SaveWorkflowCommand)command), callback, state); } else if (command is LoadWorkflowCommand) { return new TypedCompletedAsyncResult<bool>(LoadWorkflow(context, (LoadWorkflowCommand)command), callback, state); } else if (command is CreateWorkflowOwnerCommand) { return new TypedCompletedAsyncResult<bool>(CreateWorkflowOwner(context, (CreateWorkflowOwnerCommand)command), callback, state); } else if (command is DeleteWorkflowOwnerCommand) { return new TypedCompletedAsyncResult<bool>(DeleteWorkflowOwner(context, (DeleteWorkflowOwnerCommand)command), callback, state); } return new TypedCompletedAsyncResult<bool>(false, callback, state); } catch (Exception e) { return new TypedCompletedAsyncResult<Exception>(e, callback, state); } }
//The persistence engine will send a variety of commands to the configured InstanceStore, //such as CreateWorkflowOwnerCommand, SaveWorkflowCommand, and LoadWorkflowCommand. //This method is where we will handle those commands protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { IDictionary<XName, InstanceValue> data; //The CreateWorkflowOwner command instructs the instance store to create a new instance owner bound to the instanace handle if (command is CreateWorkflowOwnerCommand) { context.BindInstanceOwner(this.ownerInstanceId, Guid.NewGuid()); } //The SaveWorkflow command instructs the instance store to modify the instance bound to the instance handle or an instance key else if (command is SaveWorkflowCommand) { var saveCommand = (SaveWorkflowCommand)command; data = saveCommand.InstanceData; this.Save(data); } //The LoadWorkflow command instructs the instance store to lock and load the instance bound to the identifier in the instance handle else if (command is LoadWorkflowCommand) { var fileName = IoHelper.GetFileName(this.ownerInstanceId); using (var inputStream = new FileStream(fileName, FileMode.Open)) { data = LoadInstanceDataFromFile(inputStream); //load the data into the persistence Context context.LoadedInstance(InstanceState.Initialized, data, null, null, null); } } return new CompletedAsyncResult<bool>(true, callback, state); }
public IAsyncResult BeginExecute(InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { IAsyncResult result; if (command == null) { throw Fx.Exception.ArgumentNull("command"); } this.ThrowIfNotActive("BeginExecute"); try { this.ReconcileTransaction(); result = new ExecuteAsyncResult(this, command, timeout, callback, state); } catch (TimeoutException) { this.InstanceHandle.Free(); throw; } catch (OperationCanceledException) { this.InstanceHandle.Free(); throw; } return result; }
protected override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if(context == null) throw new ArgumentNullException("context"); if(command == null) throw new ArgumentNullException("command"); // Log which commands we are receiving Debug.WriteLine("InstanceStore::BeginTryCommand::{0} received", command.GetType().Name); IAsyncResult result = null; // validate the store lock if (command is CreateWorkflowOwnerCommand) { result = CreateWorkflowOwner(context, (CreateWorkflowOwnerCommand) command, timeout, callback, state); } if (result == null) { // Log which commands we are not handling Debug.WriteLine("InstanceStore::BeginTryCommand::{0} was not implemented", command.GetType().Name); // The base.BeginTryCommand will return a false (unhandled) return value return base.BeginTryCommand(context, command, timeout, callback, state); } return result; }
public TryLoadRunnableWorkflowAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { if (base.Store.WorkflowHostType == Guid.Empty) { throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(command.Name, System.Activities.DurableInstancing.SR.TryLoadRequiresWorkflowType, null)); } }
public SaveWorkflowAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { if (((SaveWorkflowCommand) command).InstanceKeyMetadataChanges.Count > 0) { throw FxTrace.Exception.AsError(new InstancePersistenceCommandException(System.Activities.DurableInstancing.SR.InstanceKeyMetadataChangesNotSupported)); } }
public IAsyncResult BeginExecute(InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (execute_delegate == null) { execute_delegate = new Action <InstancePersistenceCommand, TimeSpan> (Execute); } return(execute_delegate.BeginInvoke(command, timeout, callback, state)); }
public IAsyncResult BeginExecute(InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (execute_delegate == null) { execute_delegate = new Func <InstanceHandle, InstancePersistenceCommand, TimeSpan, InstanceView> (Execute); } return(execute_delegate.BeginInvoke(handle, command, timeout, callback, state)); }
internal IAsyncResult BeginTryCommandInternal(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { SqlWorkflowInstanceStoreAsyncResult result = null; if (command is SaveWorkflowCommand) { result = new SaveWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is TryLoadRunnableWorkflowCommand) { result = new TryLoadRunnableWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is LoadWorkflowCommand) { result = new LoadWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is LoadWorkflowByInstanceKeyCommand) { result = new LoadWorkflowByKeyAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is ExtendLockCommand) { result = new ExtendLockAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is DetectRunnableInstancesCommand) { result = new DetectRunnableInstancesAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is DetectActivatableWorkflowsCommand) { result = new DetectActivatableWorkflowsAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is RecoverInstanceLocksCommand) { result = new RecoverInstanceLocksAsyncResult(null, command, this, this.storeLock, null, timeout, callback, state); } else if (command is UnlockInstanceCommand) { result = new UnlockInstanceAsyncResult(null, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is CreateWorkflowOwnerCommand) { result = new CreateWorkflowOwnerAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is DeleteWorkflowOwnerCommand) { result = new DeleteWorkflowOwnerAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else if (command is QueryActivatableWorkflowsCommand) { result = new QueryActivatableWorkflowAsyncResult(context, command, this, this.storeLock, Transaction.Current, timeout, callback, state); } else { return base.BeginTryCommand(context, command, timeout, callback, state); } result.ScheduleCallback(); return result; }
protected override IAsyncResult BeginTryCommand( InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { switch(command.GetType().Name) { case "CreateWorkflowOwnerCommand": Func<Exception> createFunc = () => ProcessCreateWorkflowOwner(context, command as CreateWorkflowOwnerCommand); return createFunc.BeginInvoke(ar => { Exception ex = createFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); case "LoadWorkflowCommand": Func<Exception> loadFunc = () => ProcessLoadWorkflow(context, command as LoadWorkflowCommand); return loadFunc.BeginInvoke(ar => { Exception ex = loadFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); case "LoadWorkflowByInstanceKeyCommand": Func<Exception> loadByKeyFunc = () => ProcessLoadWorkflowByInstanceKey(context, command as LoadWorkflowByInstanceKeyCommand); return loadByKeyFunc.BeginInvoke(ar => { Exception ex = loadByKeyFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); case "SaveWorkflowCommand": Func<Exception> saveFunc = () => ProcessSaveWorkflow(context, command as SaveWorkflowCommand); return saveFunc.BeginInvoke(ar => { Exception ex = saveFunc.EndInvoke(ar); callback(new InstanceStoreAsyncResult(ar, ex)); }, state); default: return base.BeginTryCommand( context, command, timeout, callback, state); } }
public PersistenceTask(SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, InstancePersistenceCommand instancePersistenceCommand, TimeSpan taskInterval, bool automaticallyResetTimer) { this.automaticallyResetTimer = automaticallyResetTimer; this.commandCompletedCallback = Fx.ThunkCallback(new AsyncCallback(this.CommandCompletedCallback)); this.instancePersistenceCommand = instancePersistenceCommand; this.Store = store; this.StoreLock = storeLock; this.SurrogateLockOwnerId = this.StoreLock.SurrogateLockOwnerId; this.taskInterval = taskInterval; this.thisLock = new object(); }
public LoadRetryAsyncResult(SqlWorkflowInstanceStore store, InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.InstanceStore = store; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.commandTimeout = new TimeoutHelper(timeout); InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand, this.commandTimeout.RemainingTime(), LoadRetryAsyncResult.onTryCommandCallback, this); }
public ExtendLockAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : base(context, command, store, storeLock, currentTransaction, timeout, int.MaxValue, callback, state) { }
protected SqlWorkflowInstanceStoreAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : this(context, command, store, storeLock, currentTransaction, timeout, store.MaxConnectionRetries, callback, state) { }
public DetectActivatableWorkflowsAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { }
public TestDatabaseVersionAndRunAsyncResult( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, Version targetVersion, AsyncCallback callback, object state) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { this.currentTransaction = currentTransaction; this.targetVersion = targetVersion; }
public LoadWorkflowAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state ) : base(context, command, store, storeLock, currentTransaction, timeout, callback, state) { this.associatedInstanceKeys = new Dictionary<Guid, IDictionary<XName, InstanceValue>>(); this.completedInstanceKeys = new Dictionary<Guid, IDictionary<XName, InstanceValue>>(); this.objectSerializer = ObjectSerializerFactory.GetDefaultObjectSerializer(); }
public IAsyncResult BeginExecute(InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (command == null) { throw Fx.Exception.ArgumentNull("command"); } if (handle == null) { throw Fx.Exception.ArgumentNull("handle"); } if (!object.ReferenceEquals(this, handle.Store)) { throw Fx.Exception.Argument("handle", SRCore.ContextNotFromThisStore); } TimeoutHelper.ThrowIfNegativeArgument(timeout); return(InstancePersistenceContext.BeginOuterExecute(handle, command, Transaction.Current, timeout, callback, state)); }
public IAsyncResult BeginExecute(InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (command == null) { throw Fx.Exception.ArgumentNull("command"); } if (handle == null) { throw Fx.Exception.ArgumentNull("handle"); } if (!object.ReferenceEquals(this, handle.Store)) { throw Fx.Exception.Argument("handle", SRCore.ContextNotFromThisStore); } TimeoutHelper.ThrowIfNegativeArgument(timeout); return InstancePersistenceContext.BeginOuterExecute(handle, command, Transaction.Current, timeout, callback, state); }
protected internal override IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (context == null) { throw FxTrace.Exception.ArgumentNull("context"); } if (command == null) { throw FxTrace.Exception.ArgumentNull("command"); } if (!this.storeLock.IsValid && !(command is CreateWorkflowOwnerCommand)) { throw FxTrace.Exception.AsError(new InstanceOwnerException(command.Name, this.storeLock.LockOwnerId)); } if (this.IsRetryCommand(command)) { return new LoadRetryAsyncResult(this, context, command, timeout, callback, state); } return this.BeginTryCommandInternal(context, command, timeout, callback, state); }
// ExtendLockAsyncResult and RecoverInstanceLocksAsyncResult directly call this ctor protected SqlWorkflowInstanceStoreAsyncResult ( InstancePersistenceContext context, InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, int maximumRetries, AsyncCallback callback, object state ) : base(callback, state) { this.DependentTransaction = (currentTransaction != null) ? currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete) : null; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.Store = store; this.StoreLock = storeLock; this.TimeoutHelper = new TimeoutHelper(timeout); this.OnCompleting += SqlWorkflowInstanceStoreAsyncResult.finallyCallback; this.maximumRetries = maximumRetries; }
public void Execute(InstancePersistenceCommand command, TimeSpan timeout) { if (command == null) { throw Fx.Exception.ArgumentNull("command"); } ThrowIfNotActive("Execute"); try { ReconcileTransaction(); ExecuteAsyncResult.End(new ExecuteAsyncResult(this, command, timeout)); } catch (TimeoutException) { InstanceHandle.Free(); throw; } catch (OperationCanceledException) { InstanceHandle.Free(); throw; } }
public InstanceView Execute(InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout) { throw new NotImplementedException(); }
protected internal virtual IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (try_command_delegate == null) { try_command_delegate = new Func <InstancePersistenceContext, InstancePersistenceCommand, TimeSpan, bool> (TryCommand); } return(try_command_delegate.BeginInvoke(context, command, timeout, callback, state)); }
protected internal virtual IAsyncResult BeginTryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { return(new CompletedAsyncResult <bool>(false, callback, state)); }
private bool IsRetryCommand(InstancePersistenceCommand command) { if (!this.IsLockRetryEnabled()) { return false; } return ((command is LoadWorkflowByInstanceKeyCommand) || (command is LoadWorkflowCommand)); }
public IAsyncResult BeginExecute (InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (execute_delegate == null) execute_delegate = new Func<InstanceHandle, InstancePersistenceCommand, TimeSpan, InstanceView> (Execute); return execute_delegate.BeginInvoke (handle, command, timeout, callback, state); }
protected internal virtual bool TryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { return(EndTryCommand(BeginTryCommand(context, command, timeout, null, null))); }
public ExecuteAsyncResult(InstanceHandle initialInstanceHandle, InstancePersistenceCommand command, Transaction transaction, TimeSpan timeout, AsyncCallback callback, object state) : this(command, timeout, callback, state) { this.initialInstanceHandle = initialInstanceHandle; OnCompleting = new Action<AsyncResult, Exception>(SimpleCleanup); IAsyncResult result = this.initialInstanceHandle.BeginAcquireExecutionContext(transaction, this.timeoutHelper.RemainingTime(), PrepareAsyncCompletion(ExecuteAsyncResult.onAcquireContext), this); if (result.CompletedSynchronously) { // After this stage, must complete explicitly in order to get Cleanup to run correctly. bool completeSelf = false; Exception completionException = null; try { completeSelf = OnAcquireContext(result); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } completeSelf = true; completionException = exception; } if (completeSelf) { Complete(true, completionException); } } }
public ExecuteAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : this(command, timeout, callback, state) { this.context = context; this.priorAsyncResult = this.context.LastAsyncResult; Fx.Assert(this.priorAsyncResult != null, "The LastAsyncResult should already have been checked."); this.priorAsyncResult.executeCalledByCurrentCommand = true; OnCompleting = new Action<AsyncResult, Exception>(SimpleCleanup); bool completeSelf = false; bool success = false; try { this.context.LastAsyncResult = this; if (RunLoop()) { completeSelf = true; } success = true; } finally { if (!success) { this.context.LastAsyncResult = this.priorAsyncResult; } } if (completeSelf) { Complete(true); } }
protected SqlWorkflowInstanceStoreAsyncResult(System.Runtime.DurableInstancing.InstancePersistenceContext context, System.Runtime.DurableInstancing.InstancePersistenceCommand command, SqlWorkflowInstanceStore store, SqlWorkflowInstanceStoreLock storeLock, Transaction currentTransaction, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.DependentTransaction = (currentTransaction != null) ? currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete) : null; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.Store = store; this.StoreLock = storeLock; this.TimeoutHelper = new System.Runtime.TimeoutHelper(timeout); base.OnCompleting = (Action <AsyncResult, Exception>)Delegate.Combine(base.OnCompleting, finallyCallback); }
protected internal virtual IAsyncResult BeginTryCommand (InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) { if (try_command_delegate == null) try_command_delegate = new Func<InstancePersistenceContext, InstancePersistenceCommand, TimeSpan, bool> (TryCommand); return try_command_delegate.BeginInvoke (context, command, timeout, callback, state); }
public InstanceView Execute (InstanceHandle handle, InstancePersistenceCommand command, TimeSpan timeout) { throw new NotImplementedException (); }
ExecuteAsyncResult(InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.executionStack = new Stack<IEnumerator<InstancePersistenceCommand>>(2); this.timeoutHelper = new TimeoutHelper(timeout); this.currentExecution = (new List<InstancePersistenceCommand> { command }).GetEnumerator(); }
public ExecuteAsyncResult(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) : this(command, timeout, null, null) { this.context = context; this.priorAsyncResult = this.context.LastAsyncResult; Fx.Assert(this.priorAsyncResult != null, "The LastAsyncResult should already have been checked."); this.priorAsyncResult.executeCalledByCurrentCommand = true; bool success = false; try { this.context.LastAsyncResult = this; RunLoopCore(true); success = true; } finally { this.context.LastAsyncResult = this.priorAsyncResult; if (!success && this.context.IsHandleDoomedByRollback) { this.context.InstanceHandle.Free(); } } Complete(true); }
public void Execute(InstancePersistenceCommand command, TimeSpan timeout) { throw new NotImplementedException(); }
internal static InstanceView OuterExecute(InstanceHandle initialInstanceHandle, InstancePersistenceCommand command, Transaction transaction, TimeSpan timeout) { try { return ExecuteAsyncResult.End(new ExecuteAsyncResult(initialInstanceHandle, command, transaction, timeout)); } catch (TimeoutException) { initialInstanceHandle.Free(); throw; } catch (OperationCanceledException) { initialInstanceHandle.Free(); throw; } }
internal static IAsyncResult BeginOuterExecute(InstanceHandle initialInstanceHandle, InstancePersistenceCommand command, Transaction transaction, TimeSpan timeout, AsyncCallback callback, object state) { try { return new ExecuteAsyncResult(initialInstanceHandle, command, transaction, timeout, callback, state); } catch (TimeoutException) { initialInstanceHandle.Free(); throw; } catch (OperationCanceledException) { initialInstanceHandle.Free(); throw; } }
protected internal virtual bool TryCommand(InstancePersistenceContext context, InstancePersistenceCommand command, TimeSpan timeout) { throw new NotImplementedException(); }
public LoadRetryAsyncResult(SqlWorkflowInstanceStore store, System.Runtime.DurableInstancing.InstancePersistenceContext context, System.Runtime.DurableInstancing.InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.InstanceStore = store; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.commandTimeout = new TimeoutHelper(timeout); this.InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand, this.commandTimeout.RemainingTime(), onTryCommandCallback, this); }
public ExecuteAsyncResult(InstanceHandle initialInstanceHandle, InstancePersistenceCommand command, Transaction transaction, TimeSpan timeout) : this(command, timeout, null, null) { this.initialInstanceHandle = initialInstanceHandle; this.context = this.initialInstanceHandle.AcquireExecutionContext(transaction, this.timeoutHelper.RemainingTime()); Exception completionException = null; try { // After this stage, must complete explicitly in order to get Cleanup to run correctly. this.context.RootAsyncResult = this; this.context.LastAsyncResult = this; OnCompleting = new Action<AsyncResult, Exception>(Cleanup); RunLoopCore(true); if (this.transactionToCommit != null) { try { this.transactionToCommit.Commit(); } catch (TransactionException) { // Since we are enlisted in this transaction, we can ignore exceptions from Commit. } this.transactionToCommit = null; } DoWaitForTransaction(true); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } completionException = exception; } Complete(true, completionException); }