internal InstancePersistenceContext (InstanceHandle handle, InstanceView view)
		{
			if (handle == null)
				throw new ArgumentNullException ("handle");
			if (view == null)
				throw new ArgumentNullException ("view");

			InstanceHandle = handle;
			InstanceView = view;
		}
 internal InstancePersistenceEvent AddHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
 {
     lock (this.ThisLock)
     {
         InstanceNormalEvent ownerEventHelper = this.GetOwnerEventHelper(persistenceEvent, owner);
         ownerEventHelper.BoundHandles.Add(handle);
         ownerEventHelper.PendingHandles.Remove(handle);
         return (ownerEventHelper.IsSignaled ? ownerEventHelper : null);
     }
 }
 public IAsyncResult BeginWaitForEvents(InstanceHandle handle, TimeSpan timeout, AsyncCallback callback, object state)
 {
     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 InstanceHandle.BeginWaitForEvents(handle, timeout, callback, state);
 }
        InstancePersistenceContext(InstanceHandle handle)
        {
            Fx.Assert(handle != null, "Null handle passed to InstancePersistenceContext.");

            InstanceHandle = handle;

            // Fork a copy of the current view to be the new working view. It starts with no query results.
            InstanceView newView = handle.View.Clone();
            newView.InstanceStoreQueryResults = null;
            InstanceView = newView;

            this.cancellationHandlerCalled = 0;
        }
        // This can be called to remove a handle from the BoundHandles table.  It should be called only after no more commands are in progress or could be made on the handle.
        internal void Unbind(InstanceHandle handle)
        {
            Fx.Assert(object.ReferenceEquals(this, handle.Owner), "Unbind called on the wrong owner for a handle.");
            Fx.Assert(handle.Id != Guid.Empty, "Unbind called on a handle not even bound to an instance.");

            lock (HandlesLock)
            {
                // The handle may have already been bumped - only remove it if it's still it.
                InstanceHandle existingHandle;
                if (BoundHandles.TryGetValue(handle.Id, out existingHandle) && object.ReferenceEquals(handle, existingHandle))
                {
                    BoundHandles.Remove(handle.Id);
                }
            }
        }
        internal InstancePersistenceContext(InstanceHandle handle, Transaction transaction)
            : this(handle)
        {
            Fx.Assert(transaction != null, "Null Transaction passed to InstancePersistenceContext.");

            // Let's take our own clone of the transaction. We need to do this because we might need to
            // create a TransactionScope using the transaction and in cases where we are dealing with a
            // transaction that is flowed into the workflow on a message, the DependentTransaction that the
            // dispatcher creates and sets to Transaction.Current may already be Completed by the time a
            // Save operation is done. And since TransactionScope creates a DependentTransaction, it won't
            // be able to.
            // We don't create another DependentClone because we are going to do a EnlistVolatile on the
            // transaction ourselves.
            this.transaction = transaction.Clone();
            IsHostTransaction = true;
            this.eventTraceActivity = handle.EventTraceActivity;
        }
 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 void MarkInstanceOwnerCreated(Guid lockOwnerId, long surrogateLockOwnerId, InstanceHandle lockOwnerInstanceHandle, bool detectRunnableInstances, bool detectActivatableInstances)
 {
     this.lockOwnerId = lockOwnerId;
     this.SurrogateLockOwnerId = surrogateLockOwnerId;
     this.lockOwnerInstanceHandle = new WeakReference(lockOwnerInstanceHandle);
     TimeSpan hostLockRenewalPeriod = this.sqlWorkflowInstanceStore.HostLockRenewalPeriod;
     TimeSpan runnableInstancesDetectionPeriod = this.sqlWorkflowInstanceStore.RunnableInstancesDetectionPeriod;
     if (detectActivatableInstances)
     {
         this.InstanceDetectionTask = new DetectActivatableWorkflowsTask(this.sqlWorkflowInstanceStore, this, runnableInstancesDetectionPeriod);
     }
     else if (detectRunnableInstances)
     {
         this.InstanceDetectionTask = new DetectRunnableInstancesTask(this.sqlWorkflowInstanceStore, this, runnableInstancesDetectionPeriod);
     }
     this.LockRenewalTask = new System.Activities.DurableInstancing.LockRenewalTask(this.sqlWorkflowInstanceStore, this, hostLockRenewalPeriod);
     this.LockRecoveryTask = new System.Activities.DurableInstancing.LockRecoveryTask(this.sqlWorkflowInstanceStore, this, hostLockRenewalPeriod);
     if (this.InstanceDetectionTask != null)
     {
         this.InstanceDetectionTask.ResetTimer(true);
     }
     this.LockRenewalTask.ResetTimer(true);
     this.LockRecoveryTask.ResetTimer(true);
 }
 bool CreateDirectory()
 {
     this.instanceManager.InitializePersistenceProviderDirectory();
     this.instanceManager.handle = this.handle;
     this.handle = null;
     return true;
 }
        public void Open(TimeSpan timeout)
        {
            Fx.Assert(Host != null, "Extension should have been attached in WorkflowServiceHost constructor.");

            lock (this.thisLock)
            {
                ThrowIfDisposedOrImmutable(this.state);
                this.state = States.Opened;
            }
            InitializeDefinitionProvider();

            CheckPersistenceProviderBehavior();

            SetDefaultOwnerMetadata();


            if (InstanceStore != null)
            {
                using (new TransactionScope(TransactionScopeOption.Suppress))
                {
                    TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
                    InstanceHandle handle = null;
                    try
                    {
                        handle = InstanceStore.CreateInstanceHandle(null);
                        this.owner = InstanceStore.Execute(handle, GetCreateOwnerCommand(), timeoutHelper.RemainingTime()).InstanceOwner;
                        this.handle = handle;
                        handle = null;
                    }
                    catch (InstancePersistenceException exception)
                    {
                        throw FxTrace.Exception.AsError(new CommunicationException(SR.UnableToOpenAndRegisterStore, exception));
                    }
                    finally
                    {
                        if (handle != null)
                        {
                            handle.Free();
                        }
                    }
                }
            }

            InitializePersistenceProviderDirectory();
        }
            public OpenInstanceStoreAsyncResult(DurableInstanceManager instanceManager, TimeSpan timeout, AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.instanceManager = instanceManager;
                this.timeoutHelper = new TimeoutHelper(timeout);

                lock (this.instanceManager.thisLock)
                {
                    DurableInstanceManager.ThrowIfDisposedOrImmutable(this.instanceManager.state);
                    this.instanceManager.state = States.Opened;
                }

                this.instanceManager.InitializeDefinitionProvider();

                instanceManager.CheckPersistenceProviderBehavior();

                this.instanceManager.SetDefaultOwnerMetadata();

                this.OnCompleting = OpenInstanceStoreAsyncResult.onFinally;

                bool completeSelf;
                Exception completionException = null;
                try
                {
                    if (instanceManager.InstanceStore == null)
                    {
                        completeSelf = CreateDirectory();
                    }
                    else
                    {
                        this.handle = this.instanceManager.InstanceStore.CreateInstanceHandle(null);
                        IAsyncResult executeResult = this.instanceManager.InstanceStore.BeginExecute(this.handle,
                            this.instanceManager.GetCreateOwnerCommand(), this.timeoutHelper.RemainingTime(),
                            this.PrepareAsyncCompletion(OpenInstanceStoreAsyncResult.handleEndExecute), this);
                        completeSelf = SyncContinue(executeResult);
                    }
                }
                catch (Exception exception)
                {
                    if (Fx.IsFatal(exception))
                    {
                        throw;
                    }

                    completionException = exception;
                    completeSelf = true;
                }
                if (completeSelf)
                {
                    Complete(true, completionException);
                }
            }
 protected override object OnNewInstanceHandle(InstanceHandle instanceHandle)
 {
     this.MakeReadOnly();
     return new InstanceLockTracking(this);
 }
示例#13
0
            AcquireContextAsyncResult(InstanceHandle handle, Transaction hostTransaction, TimeSpan timeout, out bool setOperationPending, bool synchronous, AsyncCallback callback, object state)
                : base(callback, state)
            {
                // Need to report back to the caller whether or not we set OperationPending.
                setOperationPending = false;

                this.handle = handle;
                HostTransaction = hostTransaction;
                this.timeoutHelper = new TimeoutHelper(timeout);

                AcquireContextAsyncResult transactionWait;
                bool reuseContext = false;
                lock (this.handle.ThisLock)
                {
                    if (!this.handle.IsValid)
                    {
                        throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed));
                    }

                    if (this.handle.OperationPending)
                    {
                        throw Fx.Exception.AsError(new InvalidOperationException(SRCore.CommandExecutionCannotOverlap));
                    }
                    setOperationPending = true;
                    this.handle.OperationPending = true;

                    transactionWait = this.handle.CurrentTransactionalAsyncResult;
                    if (transactionWait != null)
                    {
                        Fx.Assert(this.handle.AcquirePending == null, "Overlapped acquires pending.");

                        // If the transaction matches but is already completed (or completing), the easiest ting to do
                        // is wait for it to complete, then try to re-enlist, and have that failure be the failure mode for Execute.
                        // We do that by following the regular, non-matching transaction path.
                        if (transactionWait.HostTransaction.Equals(hostTransaction) && !this.handle.TooLateToEnlist)
                        {
                            reuseContext = true;
                            this.executionContext = transactionWait.ReuseContext();
                            this.handle.CurrentExecutionContext = this.executionContext;
                        }
                        else
                        {
                            this.handle.AcquirePending = this;
                        }
                    }
                }

                if (transactionWait != null)
                {
                    Fx.Assert(transactionWait.IsCompleted, "Old AsyncResult must be completed by now.");

                    // Reuse the existing InstanceExecutionContext if this is the same transaction we're waiting for.
                    if (reuseContext)
                    {
                        Complete(true);
                        return;
                    }

                    TimeSpan waitTimeout = this.timeoutHelper.RemainingTime();
                    if (synchronous)
                    {
                        if (!transactionWait.WaitForHostTransaction.Wait(waitTimeout))
                        {
                            throw Fx.Exception.AsError(new TimeoutException(InternalSR.TimeoutOnOperation(waitTimeout)));
                        }
                    }
                    else
                    {
                        if (!transactionWait.WaitForHostTransaction.WaitAsync(AcquireContextAsyncResult.onHostTransaction, this, waitTimeout))
                        {
                            return;
                        }
                    }
                }

                if (DoAfterTransaction())
                {
                    Complete(true);
                }
            }
 public OpenInstanceStoreAsyncResult(DurableInstanceManager instanceManager, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
 {
     bool flag;
     this.instanceManager = instanceManager;
     this.timeoutHelper = new TimeoutHelper(timeout);
     lock (this.instanceManager.thisLock)
     {
         DurableInstanceManager.ThrowIfDisposedOrImmutable(this.instanceManager.state);
         this.instanceManager.state = 1;
     }
     instanceManager.CheckPersistenceProviderBehavior();
     this.instanceManager.SetDefaultOwnerMetadata();
     base.OnCompleting = onFinally;
     Exception exception = null;
     try
     {
         if (instanceManager.InstanceStore == null)
         {
             flag = this.CreateDirectory();
         }
         else
         {
             this.handle = this.instanceManager.InstanceStore.CreateInstanceHandle((InstanceOwner) null);
             IAsyncResult result = this.instanceManager.InstanceStore.BeginExecute(this.handle, this.instanceManager.createOwnerCommand, this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleEndExecute), this);
             flag = base.SyncContinue(result);
         }
     }
     catch (Exception exception2)
     {
         if (Fx.IsFatal(exception2))
         {
             throw;
         }
         exception = exception2;
         flag = true;
     }
     if (flag)
     {
         base.Complete(true, exception);
     }
 }
 protected override void OnFreeInstanceHandle(InstanceHandle instanceHandle, object userContext)
 {
     ((InstanceLockTracking) userContext).HandleFreed();
 }
示例#16
0
        private static void WaitForRunnableInstance(InstanceStore store, InstanceHandle ownerHandle)
        {
            IEnumerable<InstancePersistenceEvent> events = store.WaitForEvents(ownerHandle, TimeSpan.MaxValue);

            bool foundRunnable = false;

            // Loop through the persistence events looking for the HasRunnableWorkflow event (in this sample, it corresponds with
            // the workflow instance whose timer has expired and is ready to be resumed by the host).
            foreach (InstancePersistenceEvent persistenceEvent in events)
            {
                if (persistenceEvent.Equals(HasRunnableWorkflowEvent.Value))
                {
                    foundRunnable = true;
                    break;
                }
            }

            if (!foundRunnable)
            {
                throw new ApplicationException("Unexpected: No runnable instances found in the instance store");
            }
        }
            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 AcquireContextAsyncResult(InstanceHandle handle, Transaction hostTransaction, TimeSpan timeout, out bool setOperationPending, AsyncCallback callback, object state) : this(handle, hostTransaction, timeout, out setOperationPending, false, callback, state)
 {
 }
 internal static IAsyncResult BeginWaitForEvents(InstanceHandle handle, TimeSpan timeout, AsyncCallback callback, object state)
 {
     return new WaitForEventsAsyncResult(handle, timeout, callback, state);
 }
 internal InstancePersistenceContext(InstanceHandle handle, TimeSpan timeout)
     : this(handle)
 {
     this.timeout = timeout;
 }
 public void Open(TimeSpan timeout)
 {
     lock (this.thisLock)
     {
         ThrowIfDisposedOrImmutable(this.state);
         this.state = 1;
     }
     this.CheckPersistenceProviderBehavior();
     this.SetDefaultOwnerMetadata();
     if (this.InstanceStore != null)
     {
         using (new TransactionScope(TransactionScopeOption.Suppress))
         {
             TimeoutHelper helper = new TimeoutHelper(timeout);
             InstanceHandle handle = null;
             try
             {
                 handle = this.InstanceStore.CreateInstanceHandle((InstanceOwner) null);
                 this.owner = this.InstanceStore.Execute(handle, this.createOwnerCommand, helper.RemainingTime()).InstanceOwner;
                 this.handle = handle;
                 handle = null;
             }
             catch (InstancePersistenceException exception)
             {
                 throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new CommunicationException(System.ServiceModel.Activities.SR.UnableToOpenAndRegisterStore, exception));
             }
             finally
             {
                 if (handle != null)
                 {
                     handle.Free();
                 }
             }
         }
     }
     this.InitializePersistenceProviderDirectory();
 }
            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);
            }
            bool PostProcess()
            {
                //cleanup any buffered receives unassociated with workflowServiceInstances
                BufferedReceiveManager bufferedReceiveManager = this.instanceManager.Host.Extensions.Find<BufferedReceiveManager>();
                if (bufferedReceiveManager != null)
                {
                    bufferedReceiveManager.AbandonBufferedReceives();
                }

                // Send the DeleteWorkflowOwner command to the instance store.
                if (this.instanceManager.InstanceStore != null)
                {
                    IAsyncResult executeResult = null;
                    this.handle = this.instanceManager.InstanceStore.CreateInstanceHandle(this.instanceManager.owner);
                    try
                    {
                        executeResult = this.instanceManager.InstanceStore.BeginExecute(this.handle,
                            new DeleteWorkflowOwnerCommand(), this.timeoutHelper.RemainingTime(),
                            this.PrepareAsyncCompletion(CloseAsyncResult.handleEndExecute), this);
                        return (SyncContinue(executeResult));
                    }
                    // Ignore some exceptions because DeleteWorkflowOwner is best effort.
                    catch (InstancePersistenceCommandException) { }
                    catch (InstanceOwnerException) { }
                    catch (OperationCanceledException) { }
                    finally
                    {
                        if (executeResult == null)
                        {
                            this.handle.Free();
                            this.handle = null;
                        }
                    }
                    return this.SyncContinue(executeResult);
                }
                else
                {
                    CloseProviderDirectory();
                    return true;
                }
            }
        public void MarkInstanceOwnerCreated(Guid lockOwnerId, long surrogateLockOwnerId, InstanceHandle lockOwnerInstanceHandle, bool detectRunnableInstances, bool detectActivatableInstances)
        {
            Fx.Assert(this.isBeingModified, "Must have modification lock to mark owner as created");
            this.lockOwnerId = lockOwnerId;
            this.SurrogateLockOwnerId = surrogateLockOwnerId;
            this.lockOwnerInstanceHandle = new WeakReference(lockOwnerInstanceHandle);

            TimeSpan runnableInstancesDetectionPeriod = this.sqlWorkflowInstanceStore.RunnableInstancesDetectionPeriod;

            if (detectActivatableInstances)
            {
                this.InstanceDetectionTask = new DetectActivatableWorkflowsTask(this.sqlWorkflowInstanceStore, this, runnableInstancesDetectionPeriod);
            }
            else if (detectRunnableInstances)
            {
                this.InstanceDetectionTask = new DetectRunnableInstancesTask(this.sqlWorkflowInstanceStore, this, runnableInstancesDetectionPeriod);
            }

            // By setting taskTimeout value with BufferedHostLockRenewalPeriod, 
            //  BufferedHostLockRenewalPeriod becomes max sql retry duration for ExtendLock command and RecoveryIntanceLock command.            
            this.LockRenewalTask = new LockRenewalTask(this.sqlWorkflowInstanceStore, this, this.HostLockRenewalPulseInterval, this.sqlWorkflowInstanceStore.BufferedHostLockRenewalPeriod);
            this.LockRecoveryTask = new LockRecoveryTask(this.sqlWorkflowInstanceStore, this, this.HostLockRenewalPulseInterval, this.sqlWorkflowInstanceStore.BufferedHostLockRenewalPeriod);

            if (this.InstanceDetectionTask != null)
            {
                this.InstanceDetectionTask.ResetTimer(true);
            }
            this.LockRenewalTask.ResetTimer(true);
            this.LockRecoveryTask.ResetTimer(true);
        }
 public AcquireContextAsyncResult(InstanceHandle handle, Transaction hostTransaction, TimeSpan timeout, out bool setOperationPending) : this(handle, hostTransaction, timeout, out setOperationPending, true, null, null)
 {
 }
 private bool Process()
 {
     while (this.workflowServiceInstances.MoveNext())
     {
         this.currentInstance = this.workflowServiceInstances.Current.GetInstance(null);
         if (this.currentInstance != null)
         {
             IAsyncResult result = this.currentInstance.BeginReleaseInstance(false, this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleEndReleaseInstance), this);
             if (!base.CheckSyncContinue(result))
             {
                 return false;
             }
             this.currentInstance.EndReleaseInstance(result);
         }
     }
     BufferedReceiveManager manager = this.instanceManager.Host.Extensions.Find<BufferedReceiveManager>();
     if (manager != null)
     {
         manager.AbandonBufferedReceives();
     }
     if (this.instanceManager.InstanceStore == null)
     {
         return this.CloseProviderDirectory();
     }
     IAsyncResult result2 = null;
     this.handle = this.instanceManager.InstanceStore.CreateInstanceHandle(this.instanceManager.owner);
     try
     {
         result2 = this.instanceManager.InstanceStore.BeginExecute(this.handle, new DeleteWorkflowOwnerCommand(), this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleEndExecute), this);
     }
     catch (InstancePersistenceCommandException)
     {
     }
     catch (InstanceOwnerException)
     {
     }
     catch (OperationCanceledException)
     {
     }
     finally
     {
         if (result2 == null)
         {
             this.handle.Free();
             this.handle = null;
         }
     }
     return base.SyncContinue(result2);
 }
 private AcquireContextAsyncResult(InstanceHandle handle, Transaction hostTransaction, TimeSpan timeout, out bool setOperationPending, bool synchronous, AsyncCallback callback, object state) : base(callback, state)
 {
     InstanceHandle.AcquireContextAsyncResult currentTransactionalAsyncResult;
     setOperationPending = false;
     this.handle = handle;
     this.HostTransaction = hostTransaction;
     this.timeoutHelper = new TimeoutHelper(timeout);
     bool flag = false;
     lock (this.handle.ThisLock)
     {
         if (!this.handle.IsValid)
         {
             throw Fx.Exception.AsError(new OperationCanceledException(SRCore.HandleFreed));
         }
         if (this.handle.OperationPending)
         {
             throw Fx.Exception.AsError(new InvalidOperationException(SRCore.CommandExecutionCannotOverlap));
         }
         setOperationPending = true;
         this.handle.OperationPending = true;
         currentTransactionalAsyncResult = this.handle.CurrentTransactionalAsyncResult;
         if (currentTransactionalAsyncResult != null)
         {
             if (currentTransactionalAsyncResult.HostTransaction.Equals(hostTransaction) && !this.handle.TooLateToEnlist)
             {
                 flag = true;
                 this.executionContext = currentTransactionalAsyncResult.ReuseContext();
                 this.handle.CurrentExecutionContext = this.executionContext;
             }
             else
             {
                 this.handle.AcquirePending = this;
             }
         }
     }
     if (currentTransactionalAsyncResult != null)
     {
         if (flag)
         {
             base.Complete(true);
             return;
         }
         TimeSpan span = this.timeoutHelper.RemainingTime();
         if (synchronous)
         {
             if (!currentTransactionalAsyncResult.WaitForHostTransaction.Wait(span))
             {
                 throw Fx.Exception.AsError(new TimeoutException(SRCore.TimeoutOnOperation(span)));
             }
         }
         else if (!currentTransactionalAsyncResult.WaitForHostTransaction.WaitAsync(onHostTransaction, this, span))
         {
             return;
         }
     }
     if (this.DoAfterTransaction())
     {
         base.Complete(true);
     }
 }
 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 WaitForEventsAsyncResult(InstanceHandle handle, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
 {
     this.handle = handle;
     this.timeout = timeout;
     if ((this.timeout != TimeSpan.Zero) && (this.timeout != TimeSpan.MaxValue))
     {
         this.timer = new IOThreadTimer(timeoutCallback, this, false);
     }
     List<InstancePersistenceEvent> list = this.handle.StartWaiting(this, this.timer, this.timeout);
     if (list == null)
     {
         if (this.timeout == TimeSpan.Zero)
         {
             this.handle.CancelWaiting(this);
             throw Fx.Exception.AsError(new TimeoutException(SRCore.WaitForEventsTimedOut(TimeSpan.Zero)));
         }
     }
     else
     {
         this.readyEvents = list;
         base.Complete(true);
     }
 }
 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;
     }
 }