private AsyncResult.AsyncCompletion GetNextCompletion()
{
AsyncResult.AsyncCompletion asyncCompletion = this.nextAsyncCompletion;
this.transactionContext = null;
this.nextAsyncCompletion = null;
return(asyncCompletion);
}
private bool TryContinueHelper(IAsyncResult result, out AsyncResult.AsyncCompletion callback)
{
if (result != null)
{
callback = null;
if (this.checkSyncValidationFunc == null)
{
if (!result.CompletedSynchronously)
{
return(false);
}
}
else
{
if (!this.checkSyncValidationFunc(result))
{
return(false);
}
}
callback = this.GetNextCompletion();
if (callback == null)
{
AsyncResult.ThrowInvalidAsyncResult("Only call Check/SyncContinue once per async operation (once per PrepareAsyncCompletion).");
}
return(true);
}
else
{
throw new InvalidOperationException("InvalidNullAsyncResult"); //TODO: Fx.Exception.AsError(new InvalidOperationException(InternalSR.InvalidNullAsyncResult));
}
}
private static void AsyncCompletionWrapperCallback(IAsyncResult result)
{
if (result != null)
{
if (!result.CompletedSynchronously)
{
AsyncResult asyncState = (AsyncResult)result.AsyncState;
if (asyncState.OnContinueAsyncCompletion(result))
{
AsyncResult.AsyncCompletion nextCompletion = asyncState.GetNextCompletion();
if (nextCompletion == null)
{
AsyncResult.ThrowInvalidAsyncResult(result);
}
bool flag = false;
Exception exception = null;
try
{
flag = nextCompletion(result);
}
catch (Exception exception2)
{
Exception exception1 = exception2;
//TODO:
/*if (!Fx.IsFatal(exception1))
* {
* flag = true;
* exception = exception1;
* }
* else
* {
* throw;
* }
*/
throw;
}
if (flag)
{
asyncState.Complete(false, exception);
}
return;
}
else
{
return;
}
}
else
{
return;
}
}
else
{
throw new InvalidOperationException("InvalidNullAsyncResult"); //TODO: Fx.Exception.AsError(new InvalidOperationException(InternalSR.InvalidNullAsyncResult));
}
}
private bool AbandonReceiveContext(Exception operationException)
{
if (handleEndAbandonReceiveContext == null)
{
handleEndAbandonReceiveContext = new AsyncResult.AsyncCompletion(ControlOperationInvoker.ControlOperationAsyncResult.HandleEndAbandonReceiveContext);
}
this.operationException = operationException;
IAsyncResult result = this.receiveContext.BeginAbandon(TimeSpan.MaxValue, base.PrepareAsyncCompletion(handleEndAbandonReceiveContext), this);
return(base.SyncContinue(result));
}
protected bool SyncContinue(IAsyncResult result)
{
AsyncResult.AsyncCompletion asyncCompletion = null;
if (!this.TryContinueHelper(result, out asyncCompletion))
{
return(false);
}
else
{
return(asyncCompletion(result));
}
}
protected AsyncCallback PrepareAsyncCompletion(AsyncResult.AsyncCompletion callback)
{
if (this.beforePrepareAsyncCompletionAction != null)
{
this.beforePrepareAsyncCompletionAction();
}
this.nextAsyncCompletion = callback;
if (AsyncResult.asyncCompletionWrapperCallback == null)
{
AsyncResult.asyncCompletionWrapperCallback = new AsyncCallback(AsyncResult.AsyncCompletionWrapperCallback); //TODO: Fx.ThunkCallback(new AsyncCallback(AsyncResult.AsyncCompletionWrapperCallback));
}
return(AsyncResult.asyncCompletionWrapperCallback);
}
private bool ProcessReceiveContext()
{
if (this.receiveContext == null)
{
return(true);
}
if (handleEndProcessReceiveContext == null)
{
handleEndProcessReceiveContext = new AsyncResult.AsyncCompletion(WorkflowOperationContext.HandleEndProcessReceiveContext);
}
IAsyncResult result = ReceiveContextAsyncResult.BeginProcessReceiveContext(this, this.receiveContext, base.PrepareAsyncCompletion(handleEndProcessReceiveContext), this);
return(base.SyncContinue(result));
}
private static void AsyncCompletionWrapperCallback(IAsyncResult result)
{
if (result == null)
{
throw Fx.Exception.AsError(new InvalidOperationException(SRCore.InvalidNullAsyncResult), null);
}
if (result.CompletedSynchronously)
{
return;
}
AsyncResult asyncState = (AsyncResult)result.AsyncState;
if (asyncState.transactionContext != null && !asyncState.transactionContext.Signal(result))
{
return;
}
AsyncResult.AsyncCompletion nextCompletion = asyncState.GetNextCompletion();
if (nextCompletion == null)
{
AsyncResult.ThrowInvalidAsyncResult(result);
}
bool flag = false;
Exception exception = null;
try
{
flag = nextCompletion(result);
}
catch (Exception exception2)
{
Exception exception1 = exception2;
if (Fx.IsFatal(exception1))
{
throw;
}
flag = true;
exception = exception1;
}
if (flag)
{
asyncState.Complete(false, exception);
}
}
protected AsyncCallback PrepareAsyncCompletion(AsyncResult.AsyncCompletion callback)
{
if (this.transactionContext != null)
{
if (!this.transactionContext.IsPotentiallyAbandoned)
{
this.transactionContext.Prepared();
}
else
{
this.transactionContext = null;
}
}
this.nextAsyncCompletion = callback;
if (AsyncResult.asyncCompletionWrapperCallback == null)
{
AsyncResult.asyncCompletionWrapperCallback = new AsyncCallback(AsyncResult.AsyncCompletionWrapperCallback);
}
return(AsyncResult.asyncCompletionWrapperCallback);
}
private bool TryContinueHelper(IAsyncResult result, out AsyncResult.AsyncCompletion callback)
{
if (result == null)
{
throw Fx.Exception.AsError(new InvalidOperationException(SRCore.InvalidNullAsyncResult), null);
}
callback = null;
if (!result.CompletedSynchronously)
{
if (!object.ReferenceEquals(result, this.deferredTransactionalResult))
{
return(false);
}
if (this.transactionContext == null || !this.transactionContext.IsSignalled)
{
AsyncResult.ThrowInvalidAsyncResult(result);
}
this.deferredTransactionalResult = null;
}
else if (this.transactionContext != null)
{
if (this.transactionContext.State != AsyncResult.TransactionSignalState.Completed)
{
AsyncResult.ThrowInvalidAsyncResult("Check/SyncContinue cannot be called from within the PrepareTransactionalCall using block.");
}
else if (this.transactionContext.IsSignalled)
{
AsyncResult.ThrowInvalidAsyncResult(result);
}
}
callback = this.GetNextCompletion();
if (callback == null)
{
AsyncResult.ThrowInvalidAsyncResult("Only call Check/SyncContinue once per async operation (once per PrepareAsyncCompletion).");
}
return(true);
}
private AsyncCallback PrepareInnerAsyncCompletion(AsyncResult.AsyncCompletion innerCallback)
{
this.nextInnerAsyncCompletion = innerCallback;
return base.PrepareAsyncCompletion(outermostCallback);
}
private AsyncResult.AsyncCompletion GetNextInnerAsyncCompletion()
{
AsyncResult.AsyncCompletion nextInnerAsyncCompletion = this.nextInnerAsyncCompletion;
this.nextInnerAsyncCompletion = null;
return nextInnerAsyncCompletion;
}
private bool HandleEndAcquireReference()
{
this.referenceAcquired = true;
if (!this.instance.TryReleaseLastReference())
{
return true;
}
if (handleEndAbandon == null)
{
handleEndAbandon = new AsyncResult.AsyncCompletion(WorkflowServiceInstance.UnloadInstancePolicyHelper.UnlockAndAbortAsyncResult.HandleEndAbandon);
}
IAsyncResult result = this.instance.BeginAbandon(new FaultException(OperationExecutionFault.CreateAbortedFault(System.ServiceModel.Activities.SR.DefaultAbortReason)), false, this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleEndAbandon), this);
return base.SyncContinue(result);
}
private bool Track()
{
if ((this.instance.state == WorkflowServiceInstance.State.Aborted) || !this.instance.Controller.HasPendingTrackingRecords)
{
return this.ReleaseLock();
}
if (handleEndTrack == null)
{
handleEndTrack = new AsyncResult.AsyncCompletion(WorkflowServiceInstance.SimpleOperationAsyncResult.HandleEndTrack);
}
IAsyncResult result = this.instance.Controller.BeginFlushTrackingRecords(this.instance.trackTimeout, base.PrepareAsyncCompletion(handleEndTrack), this);
return (result.CompletedSynchronously && HandleEndTrack(result));
}
private bool AttachTransaction()
{
if ((this.OperationTransaction != null) && (this.Instance.transactionContext == null))
{
this.Instance.transactionContext = new TransactionContext(this.Instance, this.OperationTransaction);
this.Instance.isInTransaction = true;
this.Instance.isRunnable = false;
}
if (this.IsSynchronousOperation)
{
this.PerformOperation();
return this.Track();
}
if (handleEndPerformOperation == null)
{
handleEndPerformOperation = new AsyncResult.AsyncCompletion(WorkflowServiceInstance.SimpleOperationAsyncResult.HandleEndPerformOperation);
}
IAsyncResult result = this.BeginPerformOperation(base.PrepareAsyncCompletion(handleEndPerformOperation), this);
return (result.CompletedSynchronously && HandleEndPerformOperation(result));
}
private bool ReleasePersistenceContext()
{
if (this.workflowInstance.persistenceContext.State != CommunicationState.Opened)
{
return true;
}
if (onReleasePersistenceContext == null)
{
onReleasePersistenceContext = new AsyncResult.AsyncCompletion(WorkflowServiceInstance.ReleaseInstanceAsyncResult.OnReleasePersistenceContext);
}
IAsyncResult result = this.workflowInstance.persistenceContext.BeginRelease(this.workflowInstance.persistTimeout, base.PrepareAsyncCompletion(onReleasePersistenceContext), this);
return base.SyncContinue(result);
}
private bool ReleaseInstance()
{
if (handleEndUnload == null)
{
handleEndUnload = new AsyncResult.AsyncCompletion(WorkflowServiceInstance.ReleaseInstanceAsyncResult.HandleEndUnload);
}
IAsyncResult result = null;
try
{
if (this.isTryUnload)
{
result = this.BeginTryUnload(this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleEndUnload), this);
}
else
{
result = this.BeginUnload(this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleEndUnload), this);
}
}
catch (FaultException exception)
{
if (!OperationExecutionFault.IsAbortedFaultException(exception))
{
throw;
}
System.ServiceModel.Activities.FxTrace.Exception.AsWarning(exception);
return true;
}
return (result.CompletedSynchronously && HandleEndUnload(result));
}
private bool ProcessReceiveContext()
{
if (this.receiveContext == null)
{
return true;
}
if (handleEndProcessReceiveContext == null)
{
handleEndProcessReceiveContext = new AsyncResult.AsyncCompletion(WorkflowOperationContext.HandleEndProcessReceiveContext);
}
IAsyncResult result = ReceiveContextAsyncResult.BeginProcessReceiveContext(this, this.receiveContext, base.PrepareAsyncCompletion(handleEndProcessReceiveContext), this);
return base.SyncContinue(result);
}
private bool AbandonReceiveContext(Exception operationException)
{
if (handleEndAbandonReceiveContext == null)
{
handleEndAbandonReceiveContext = new AsyncResult.AsyncCompletion(ControlOperationInvoker.ControlOperationAsyncResult.HandleEndAbandonReceiveContext);
}
this.operationException = operationException;
IAsyncResult result = this.receiveContext.BeginAbandon(TimeSpan.MaxValue, base.PrepareAsyncCompletion(handleEndAbandonReceiveContext), this);
return base.SyncContinue(result);
}
protected bool CheckSyncContinue(IAsyncResult result)
{
AsyncResult.AsyncCompletion asyncCompletion = null;
return(this.TryContinueHelper(result, out asyncCompletion));
}
static AcceptMessageSessionAsyncResult()
{
AcceptMessageSessionAsyncResult.operationComplete = new AsyncResult.AsyncCompletion(AcceptMessageSessionAsyncResult.OperationComplete);
}
private static bool OnReleasePersistenceContext(IAsyncResult result)
{
WorkflowServiceInstance.ReleaseInstanceAsyncResult asyncState = (WorkflowServiceInstance.ReleaseInstanceAsyncResult) result.AsyncState;
asyncState.workflowInstance.persistenceContext.EndRelease(result);
if (onClosePersistenceContext == null)
{
onClosePersistenceContext = new AsyncResult.AsyncCompletion(WorkflowServiceInstance.ReleaseInstanceAsyncResult.OnClosePersistenceContext);
}
IAsyncResult result3 = asyncState.workflowInstance.persistenceContext.BeginClose(asyncState.timeoutHelper.RemainingTime(), asyncState.PrepareAsyncCompletion(onClosePersistenceContext), asyncState);
return asyncState.SyncContinue(result3);
}
