public static InstancePersistenceContext End(IAsyncResult result) { AcquireContextAsyncResult pThis = AsyncResult.End <AcquireContextAsyncResult>(result); Fx.Assert(pThis.executionContext != null, "Somehow the execution context didn't get set."); return(pThis.executionContext); }
static void OnHostTransaction(object state, TimeoutException timeoutException) { AcquireContextAsyncResult pThis = (AcquireContextAsyncResult)state; Exception exception = timeoutException; bool completeSelf = exception != null; if (!completeSelf) { try { if (pThis.DoAfterTransaction()) { completeSelf = true; } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } exception = e; completeSelf = true; } } if (completeSelf) { if (exception != null) { pThis.handle.FinishOperation(); } pThis.Complete(false, exception); } }
void OnRollBack(AcquireContextAsyncResult rollingBack) { bool rollbackNeeded = false; lock (ThisLock) { TooLateToEnlist = true; if (OperationPending && AcquirePending == null) { Fx.Assert(CurrentExecutionContext != null, "Should either be acquiring or executing in RollBack."); this.pendingRollback = rollingBack; // Don't prepare and roll back. this.pendingPreparingEnlistment = null; } else { rollbackNeeded = true; } } if (rollbackNeeded) { rollingBack.RollBack(); } }
void FinishOperation() { List <InstanceHandleReference> handlesPendingResolution = null; try { bool needNotification; PreparingEnlistment preparingEnlistment; AcquireContextAsyncResult pendingRollback; lock (ThisLock) { OperationPending = false; AcquirePending = null; CurrentExecutionContext = null; // This means we could have bound the handle, but didn't - clear the state here. if (this.inProgressBind != null && (Version == -1 || !IsValid)) { Owner.CancelBind(ref this.inProgressBind, ref handlesPendingResolution); } else if (Version != -1 && !IsValid) { // This means the handle was successfully bound in the past. Need to remove it from the table of handles. Owner.Unbind(this); } needNotification = this.needFreedNotification; this.needFreedNotification = false; preparingEnlistment = this.pendingPreparingEnlistment; this.pendingPreparingEnlistment = null; pendingRollback = this.pendingRollback; this.pendingRollback = null; } try { if (needNotification) { Store.FreeInstanceHandle(this, ProviderObject); } } finally { if (pendingRollback != null) { Fx.Assert(preparingEnlistment == null, "Should not have both."); pendingRollback.RollBack(); } else if (preparingEnlistment != null) { preparingEnlistment.Prepared(); } } } finally { InstanceOwner.ResolveHandles(handlesPendingResolution); } }
private void FinishOperation() { List <InstanceHandleReference> handlesPendingResolution = null; try { bool needFreedNotification; PreparingEnlistment pendingPreparingEnlistment; AcquireContextAsyncResult pendingRollback; lock (this.ThisLock) { this.OperationPending = false; this.AcquirePending = null; this.CurrentExecutionContext = null; if ((this.inProgressBind != null) && ((this.Version == -1L) || !this.IsValid)) { this.Owner.CancelBind(ref this.inProgressBind, ref handlesPendingResolution); } else if ((this.Version != -1L) && !this.IsValid) { this.Owner.Unbind(this); } needFreedNotification = this.needFreedNotification; this.needFreedNotification = false; pendingPreparingEnlistment = this.pendingPreparingEnlistment; this.pendingPreparingEnlistment = null; pendingRollback = this.pendingRollback; this.pendingRollback = null; } try { if (needFreedNotification) { this.Store.FreeInstanceHandle(this, this.ProviderObject); } } finally { if (pendingRollback != null) { pendingRollback.RollBack(); } else if (pendingPreparingEnlistment != null) { pendingPreparingEnlistment.Prepared(); } } } finally { InstanceOwner.ResolveHandles(handlesPendingResolution); } }
internal IAsyncResult BeginAcquireExecutionContext(Transaction hostTransaction, TimeSpan timeout, AsyncCallback callback, object state) { bool setOperationPending = false; IAsyncResult result = null; try { result = new AcquireContextAsyncResult(this, hostTransaction, timeout, out setOperationPending, callback, state); return(result); } finally { if (result == null && setOperationPending) { FinishOperation(); } } }
internal IAsyncResult BeginAcquireExecutionContext(Transaction hostTransaction, TimeSpan timeout, AsyncCallback callback, object state) { IAsyncResult result2; bool setOperationPending = false; IAsyncResult result = null; try { result = new AcquireContextAsyncResult(this, hostTransaction, timeout, out setOperationPending, callback, state); result2 = result; } finally { if ((result == null) && setOperationPending) { this.FinishOperation(); } } return result2; }
internal InstancePersistenceContext AcquireExecutionContext(Transaction hostTransaction, TimeSpan timeout) { bool setOperationPending = false; InstancePersistenceContext result = null; try { result = AcquireContextAsyncResult.End(new AcquireContextAsyncResult(this, hostTransaction, timeout, out setOperationPending)); Fx.AssertAndThrow(result != null, "Null result returned from AcquireContextAsyncResult (synchronous)."); return(result); } finally { if (result == null && setOperationPending) { FinishOperation(); } } }
bool DoAfterTransaction() { AcquireContextAsyncResult setWaitTo = null; try { lock (this.handle.ThisLock) { if (!this.handle.IsValid) { throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed)); } if (HostTransaction == null) { this.executionContext = new InstancePersistenceContext(this.handle, this.timeoutHelper.RemainingTime()); } else { this.executionContext = new InstancePersistenceContext(this.handle, HostTransaction); } this.handle.AcquirePending = null; this.handle.CurrentExecutionContext = this.executionContext; this.handle.TooLateToEnlist = false; } if (HostTransaction != null) { WaitForHostTransaction = new AsyncWaitHandle(EventResetMode.ManualReset); HostTransaction.EnlistVolatile(this, EnlistmentOptions.None); setWaitTo = this; } } finally { this.handle.CurrentTransactionalAsyncResult = setWaitTo; } return(true); }
private void OnRollBack(AcquireContextAsyncResult rollingBack) { bool flag = false; lock (this.ThisLock) { this.TooLateToEnlist = true; if (this.OperationPending && (this.AcquirePending == null)) { this.pendingRollback = rollingBack; this.pendingPreparingEnlistment = null; } else { flag = true; } } if (flag) { rollingBack.RollBack(); } }
private void FinishOperation() { List<InstanceHandleReference> handlesPendingResolution = null; try { bool needFreedNotification; PreparingEnlistment pendingPreparingEnlistment; AcquireContextAsyncResult pendingRollback; lock (this.ThisLock) { this.OperationPending = false; this.AcquirePending = null; this.CurrentExecutionContext = null; if ((this.inProgressBind != null) && ((this.Version == -1L) || !this.IsValid)) { this.Owner.CancelBind(ref this.inProgressBind, ref handlesPendingResolution); } else if ((this.Version != -1L) && !this.IsValid) { this.Owner.Unbind(this); } needFreedNotification = this.needFreedNotification; this.needFreedNotification = false; pendingPreparingEnlistment = this.pendingPreparingEnlistment; this.pendingPreparingEnlistment = null; pendingRollback = this.pendingRollback; this.pendingRollback = null; } try { if (needFreedNotification) { this.Store.FreeInstanceHandle(this, this.ProviderObject); } } finally { if (pendingRollback != null) { pendingRollback.RollBack(); } else if (pendingPreparingEnlistment != null) { pendingPreparingEnlistment.Prepared(); } } } finally { InstanceOwner.ResolveHandles(handlesPendingResolution); } }
internal InstancePersistenceContext EndAcquireExecutionContext(IAsyncResult result) { return(AcquireContextAsyncResult.End(result)); }
void FinishOperation() { List<InstanceHandleReference> handlesPendingResolution = null; try { bool needNotification; PreparingEnlistment preparingEnlistment; AcquireContextAsyncResult pendingRollback; lock (ThisLock) { OperationPending = false; AcquirePending = null; CurrentExecutionContext = null; // This means we could have bound the handle, but didn't - clear the state here. if (this.inProgressBind != null && (Version == -1 || !IsValid)) { Owner.CancelBind(ref this.inProgressBind, ref handlesPendingResolution); } else if (Version != -1 && !IsValid) { // This means the handle was successfully bound in the past. Need to remove it from the table of handles. Owner.Unbind(this); } needNotification = this.needFreedNotification; this.needFreedNotification = false; preparingEnlistment = this.pendingPreparingEnlistment; this.pendingPreparingEnlistment = null; pendingRollback = this.pendingRollback; this.pendingRollback = null; } try { if (needNotification) { Store.FreeInstanceHandle(this, ProviderObject); } } finally { if (pendingRollback != null) { Fx.Assert(preparingEnlistment == null, "Should not have both."); pendingRollback.RollBack(); } else if (preparingEnlistment != null) { preparingEnlistment.Prepared(); } } } finally { InstanceOwner.ResolveHandles(handlesPendingResolution); } }