public static object EndProcessRequest(IAsyncResult result, out object[] outputs)
{
WorkflowOperationContext thisPtr = AsyncResult.End <WorkflowOperationContext>(result);
outputs = thisPtr.outputs;
return(thisPtr.operationReturnValue);
}
static void Finally(AsyncResult result, Exception completionException)
{
WorkflowOperationContext thisPtr = (WorkflowOperationContext)result;
thisPtr.EmitTransferFromInstanceId();
if (completionException != null)
{
if (completionException is FaultException)
{
thisPtr.TrackMethodFaulted();
}
else
{
thisPtr.TrackMethodFailed();
}
}
else
{
thisPtr.TrackMethodCompleted(thisPtr.operationReturnValue);
}
thisPtr.ProcessFinalizationTraces();
// will be a no-op if we were never added to the instance
thisPtr.workflowInstance.ReleaseContext(thisPtr);
thisPtr.RemovePendingOperation();
}
private ReceiveContextAsyncResult(WorkflowOperationContext context, ReceiveContext receiveContext, AsyncCallback callback, object state) : base(callback, state)
{
this.context = context;
this.receiveContext = receiveContext;
if (this.ProcessReceiveContext())
{
base.Complete(true);
}
}
private static bool HandleEndResumeBookmark(IAsyncResult result)
{
WorkflowOperationContext asyncState = (WorkflowOperationContext)result.AsyncState;
bool flag = false;
bool flag2 = true;
try
{
if (asyncState.workflowInstance.EndResumeProtocolBookmark(result) != BookmarkResumptionResult.Success)
{
asyncState.OperationContext.Host.RaiseUnknownMessageReceived(asyncState.OperationContext.IncomingMessage);
if ((asyncState.workflowInstance.BufferedReceiveManager != null) && asyncState.workflowInstance.BufferedReceiveManager.BufferReceive(asyncState.OperationContext, asyncState.receiveContext, asyncState.bookmark.Name, BufferedReceiveState.WaitingOnBookmark, false))
{
if (System.ServiceModel.Activities.TD.BufferOutOfOrderMessageNoBookmarkIsEnabled())
{
System.ServiceModel.Activities.TD.BufferOutOfOrderMessageNoBookmark(asyncState.workflowInstance.Id.ToString(), asyncState.bookmark.Name);
}
flag2 = false;
}
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new FaultException(OperationExecutionFault.CreateOperationNotAvailableFault(asyncState.workflowInstance.Id, asyncState.bookmark.Name)));
}
lock (asyncState.thisLock)
{
if (asyncState.CurrentState == State.ResultReceived)
{
asyncState.CurrentState = State.Completed;
if (asyncState.pendingException != null)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(asyncState.pendingException);
}
flag = true;
}
else
{
asyncState.CurrentState = State.WaitForResult;
flag = false;
}
if (flag)
{
flag = asyncState.ProcessReceiveContext();
}
flag2 = false;
}
}
finally
{
if (flag2)
{
BufferedReceiveManager.AbandonReceiveContext(asyncState.receiveContext);
}
asyncState.RemovePendingOperation();
}
return(flag);
}
protected internal virtual Bookmark OnResolveBookmark(WorkflowOperationContext context, out BookmarkScope bookmarkScope, out object value)
{
CorrelationMessageProperty property;
if (CorrelationMessageProperty.TryGet(context.OperationContext.IncomingMessageProperties, out property))
{
bookmarkScope = new BookmarkScope(property.CorrelationKey.Value);
}
else
{
bookmarkScope = BookmarkScope.Default;
}
value = context;
return this.bookmark;
}
private void OnMessage(NativeActivityContext executionContext, Bookmark bookmark, object state)
{
WorkflowOperationContext context = state as WorkflowOperationContext;
if (context == null)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.WorkflowMustBeHosted));
}
CorrelationResponseContext responseContext = new CorrelationResponseContext {
WorkflowOperationContext = context
};
ReceiveMessageInstanceData instance = new ReceiveMessageInstanceData(responseContext);
this.SetupTransaction(executionContext, instance);
}
protected internal override Bookmark OnResolveBookmark(WorkflowOperationContext context, out BookmarkScope bookmarkScope, out object value)
{
CorrelationMessageProperty property;
if (CorrelationMessageProperty.TryGet(context.OperationContext.IncomingMessageProperties, out property))
{
bookmarkScope = new BookmarkScope(property.CorrelationKey.Value);
}
else
{
bookmarkScope = null;
}
WorkflowHostingResponseContext responseContext = new WorkflowHostingResponseContext(context);
Bookmark bookmark = this.hostingEndpoint.OnResolveBookmark(context.Inputs, context.OperationContext, responseContext, out value);
if (bookmark == null)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(WorkflowHostingEndpoint.CreateDispatchFaultException());
}
return(bookmark);
}
private void SetupTransaction(NativeActivityContext executionContext, ReceiveMessageInstanceData instance)
{
WorkflowOperationContext workflowOperationContext = instance.CorrelationResponseContext.WorkflowOperationContext;
if (workflowOperationContext.CurrentTransaction != null)
{
RuntimeTransactionHandle handle = null;
handle = executionContext.Properties.Find(runtimeTransactionHandlePropertyName) as RuntimeTransactionHandle;
if (handle == null)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.ReceiveNotWithinATransactedReceiveScope));
}
TransactedReceiveData data = executionContext.Properties.Find(TransactedReceiveData.TransactedReceiveDataExecutionPropertyName) as TransactedReceiveData;
if ((data != null) && this.AdditionalData.IsFirstReceiveOfTransactedReceiveScopeTree)
{
data.InitiatingTransaction = workflowOperationContext.OperationContext.TransactionFacet.Current;
}
Transaction currentTransaction = handle.GetCurrentTransaction(executionContext);
if (currentTransaction != null)
{
if (!currentTransaction.Equals(workflowOperationContext.CurrentTransaction))
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.FlowedTransactionDifferentFromAmbient));
}
this.ServerScheduleOnReceivedMessage(executionContext, instance);
}
else
{
ReceiveMessageState state = new ReceiveMessageState {
CurrentTransaction = workflowOperationContext.CurrentTransaction.Clone(),
Instance = instance
};
handle.RequireTransactionContext(executionContext, new Action <NativeActivityTransactionContext, object>(this.RequireContextCallback), state);
}
}
else
{
this.ServerScheduleOnReceivedMessage(executionContext, instance);
}
}
static bool HandleEndWaitForPendingOperations(IAsyncResult result)
{
WorkflowOperationContext thisPtr = (WorkflowOperationContext)result.AsyncState;
thisPtr.pendingAsyncResult = result;
bool success = false;
try
{
thisPtr.workflowInstance.EndWaitForPendingOperations(result);
bool retval = thisPtr.OnResumeBookmark();
success = true;
return(retval);
}
finally
{
if (!success)
{
thisPtr.RemovePendingOperation();
}
}
}
private static void Finally(AsyncResult result, Exception completionException)
{
WorkflowOperationContext context = (WorkflowOperationContext)result;
context.EmitTransferFromInstanceId();
if (completionException != null)
{
if (completionException is FaultException)
{
context.TrackMethodFaulted();
}
else
{
context.TrackMethodFailed();
}
}
else
{
context.TrackMethodCompleted(context.operationReturnValue);
}
context.ProcessFinalizationTraces();
context.workflowInstance.ReleaseContext(context);
context.RemovePendingOperation();
}
protected internal override Bookmark OnResolveBookmark(WorkflowOperationContext context, out BookmarkScope bookmarkScope, out object value)
{
CorrelationMessageProperty correlationMessageProperty;
if (CorrelationMessageProperty.TryGet(context.OperationContext.IncomingMessageProperties, out correlationMessageProperty))
{
bookmarkScope = new BookmarkScope(correlationMessageProperty.CorrelationKey.Value);
}
else
{
bookmarkScope = null;
}
WorkflowHostingResponseContext responseContext = new WorkflowHostingResponseContext(context);
Fx.Assert(context.ServiceEndpoint is WorkflowHostingEndpoint, "serviceEnpoint must be of WorkflowHostingEndpoint type!");
Bookmark bookmark = ((WorkflowHostingEndpoint)context.ServiceEndpoint).OnResolveBookmark(context.Inputs, context.OperationContext, responseContext, out value);
if (bookmark == null)
{
throw FxTrace.Exception.AsError(CreateDispatchFaultException());
}
return(bookmark);
}
private static bool HandleEndWaitForPendingOperations(IAsyncResult result)
{
bool flag3;
WorkflowOperationContext asyncState = (WorkflowOperationContext)result.AsyncState;
asyncState.pendingAsyncResult = result;
bool flag = false;
try
{
asyncState.workflowInstance.EndWaitForPendingOperations(result);
bool flag2 = asyncState.OnResumeBookmark();
flag = true;
flag3 = flag2;
}
finally
{
if (!flag)
{
asyncState.RemovePendingOperation();
}
}
return(flag3);
}
protected internal override Bookmark OnResolveBookmark(WorkflowOperationContext context, out BookmarkScope bookmarkScope, out object value)
{
CorrelationMessageProperty correlationMessageProperty;
if (CorrelationMessageProperty.TryGet(context.OperationContext.IncomingMessageProperties, out correlationMessageProperty))
{
bookmarkScope = new BookmarkScope(correlationMessageProperty.CorrelationKey.Value);
}
else
{
bookmarkScope = null;
}
WorkflowHostingResponseContext responseContext = new WorkflowHostingResponseContext(context);
Fx.Assert(context.ServiceEndpoint is WorkflowHostingEndpoint, "serviceEnpoint must be of WorkflowHostingEndpoint type!");
Bookmark bookmark = ((WorkflowHostingEndpoint)context.ServiceEndpoint).OnResolveBookmark(context.Inputs, context.OperationContext, responseContext, out value);
if (bookmark == null)
{
throw FxTrace.Exception.AsError(CreateDispatchFaultException());
}
return bookmark;
}
public void ReleaseContext(WorkflowOperationContext context)
{
lock (this.thisLock)
{
this.pendingRequests.Remove(context);
}
}
protected internal override Bookmark OnResolveBookmark(WorkflowOperationContext context, out BookmarkScope bookmarkScope, out object value)
{
CorrelationMessageProperty property;
if (CorrelationMessageProperty.TryGet(context.OperationContext.IncomingMessageProperties, out property))
{
bookmarkScope = new BookmarkScope(property.CorrelationKey.Value);
}
else
{
bookmarkScope = null;
}
WorkflowHostingResponseContext responseContext = new WorkflowHostingResponseContext(context);
Bookmark bookmark = this.hostingEndpoint.OnResolveBookmark(context.Inputs, context.OperationContext, responseContext, out value);
if (bookmark == null)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(WorkflowHostingEndpoint.CreateDispatchFaultException());
}
return bookmark;
}
public static IAsyncResult BeginProcessReceiveContext(WorkflowOperationContext context, ReceiveContext receiveContext, AsyncCallback callback, object state)
{
return new ReceiveContextAsyncResult(context, receiveContext, callback, state);
}
ReceiveContextAsyncResult(WorkflowOperationContext context, ReceiveContext receiveContext, AsyncCallback callback, object state)
: base(callback, state)
{
this.context = context;
this.receiveContext = receiveContext;
if (ProcessReceiveContext())
{
base.Complete(true);
}
}
internal WorkflowHostingResponseContext(WorkflowOperationContext context)
{
this.context = context;
}
public static IAsyncResult BeginProcessReceiveContext(WorkflowOperationContext context, ReceiveContext receiveContext, AsyncCallback callback, object state)
{
return(new ReceiveContextAsyncResult(context, receiveContext, callback, state));
}
// Used by BookmarkResumption Endpoint
internal WorkflowHostingResponseContext(WorkflowOperationContext context)
{
this.context = context;
}
static bool HandleEndResumeBookmark(IAsyncResult result)
{
WorkflowOperationContext thisPtr = (WorkflowOperationContext)result.AsyncState;
bool completed = false;
bool shouldAbandon = true;
try
{
BookmarkResumptionResult resumptionResult = thisPtr.workflowInstance.EndResumeProtocolBookmark(result);
if (resumptionResult != BookmarkResumptionResult.Success)
{
// Raise UnkownMessageReceivedEvent when we fail to resume bookmark
thisPtr.OperationContext.Host.RaiseUnknownMessageReceived(thisPtr.OperationContext.IncomingMessage);
// Only delay-retry this operation once (and only if retries are supported). Future calls will ensure the bookmark is set.
if (thisPtr.workflowInstance.BufferedReceiveManager != null)
{
bool bufferSuccess = thisPtr.workflowInstance.BufferedReceiveManager.BufferReceive(
thisPtr.OperationContext, thisPtr.receiveContext, thisPtr.bookmark.Name, BufferedReceiveState.WaitingOnBookmark, false);
if (bufferSuccess)
{
if (TD.BufferOutOfOrderMessageNoBookmarkIsEnabled())
{
TD.BufferOutOfOrderMessageNoBookmark(thisPtr.eventTraceActivity, thisPtr.workflowInstance.Id.ToString(), thisPtr.bookmark.Name);
}
shouldAbandon = false;
}
}
// The throw exception is intentional whether or not BufferedReceiveManager is set.
// This is to allow exception to bubble up the stack to WCF to cleanup various state (like Transaction).
// This is queue scenario and as far as the client is concerned, the client will not see any exception.
throw FxTrace.Exception.AsError(new FaultException(OperationExecutionFault.CreateOperationNotAvailableFault(thisPtr.workflowInstance.Id, thisPtr.bookmark.Name)));
}
lock (thisPtr.thisLock)
{
if (thisPtr.CurrentState == State.ResultReceived)
{
thisPtr.CurrentState = State.Completed;
if (thisPtr.pendingException != null)
{
throw FxTrace.Exception.AsError(thisPtr.pendingException);
}
completed = true;
}
else
{
thisPtr.CurrentState = State.WaitForResult;
completed = false;
}
// we are not really completed until the ReceiveContext finishes its work
if (completed)
{
completed = thisPtr.ProcessReceiveContext();
}
shouldAbandon = false;
}
}
finally
{
if (shouldAbandon)
{
BufferedReceiveManager.AbandonReceiveContext(thisPtr.receiveContext);
}
thisPtr.RemovePendingOperation();
}
return(completed);
}
