private bool ProcessQueueItem(ActivityExecutionContext context)
{
WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>();
if (!qService.Exists(this.QueueName))
{
return(false);
}
WorkflowQueue queue = qService.GetWorkflowQueue(this.QueueName);
// If the queue has messages, then process the first one
if (queue.Count == 0)
{
return(false);
}
FileWatcherEventArgs e = (FileWatcherEventArgs)queue.Dequeue();
// Raise the FileSystemEvent
base.RaiseGenericEvent <FileWatcherEventArgs>(FileSystemEvent.FileWatcherEventHandlerEvent, this, e);
DoUnsubscribe(context, this);
DeleteQueue(context);
return(true);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (this.Fault == null)
{
throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, "Error_PropertyNotSet", new object[] { FaultProperty.Name }));
}
WorkflowQueuingService service = executionContext.GetService <WorkflowQueuingService>();
base.RaiseEvent(SendingFaultEvent, this, EventArgs.Empty);
WebServiceInputActivity activityByName = base.GetActivityByName(this.InputActivityName) as WebServiceInputActivity;
IComparable queueName = new EventQueueName(activityByName.InterfaceType, activityByName.MethodName, activityByName.QualifiedName);
IMethodResponseMessage message = null;
WorkflowQueue workflowQueue = service.GetWorkflowQueue(queueName);
if (workflowQueue.Count != 0)
{
message = workflowQueue.Dequeue() as IMethodResponseMessage;
}
message.SendException(this.Fault);
return(ActivityExecutionStatus.Closed);
}
void q_QueueItemAvailable(object sender, QueueEventArgs e)
{
ActivityExecutionContext aec = sender as ActivityExecutionContext;
if (aec != null)
{
WorkflowQueuingService qs = aec.GetService <WorkflowQueuingService>();
WorkflowQueue q = qs.GetWorkflowQueue(e.QueueName);
//get the outparameters from the workflow
object o = q.Dequeue();
//delete the queue
qs.DeleteWorkflowQueue(e.QueueName);
Dictionary <string, object> outparams = o as Dictionary <string, object>;
if (outparams != null)
{
foreach (KeyValuePair <string, object> item in outparams)
{
if (this.Parameters.Contains(item.Key))
{
//modify the value
this.Parameters[item.Key].SetValue(WorkflowParameterBinding.ValueProperty, item.Value);
}
}
}
aec.CloseActivity();
}
}
public virtual WorkflowBase GetNextWorkflow()
{
if (WorkflowQueue.Count == 0)
{
return(null);
}
var wftype = WorkflowQueue.Dequeue();
var wf = CreateInstance <WorkflowBase>(wftype);
return(wf);
}
/// <summary>
/// Queues the item available.
/// </summary>
/// <param name="ctx">The CTX.</param>
protected ActivityExecutionStatus ProcessQueueElement(ActivityExecutionContext ctx)
{
WorkflowQueue queue = GetQueue(ctx);
AssignmentEntity assignment = queue.Dequeue() as AssignmentEntity;
if (assignment != null)
{
return(CheckAssignmentCompletion(assignment));
}
return(ActivityExecutionStatus.Executing);
}
void IEventActivity.Unsubscribe(ActivityExecutionContext parentContext, IActivityEventListener <QueueEventArgs> parentEventHandler)
{
if (parentContext == null)
{
throw new ArgumentNullException("parentContext");
}
if (parentEventHandler == null)
{
throw new ArgumentNullException("parentEventHandler");
}
System.Diagnostics.Debug.Assert(this.SubscriptionID != Guid.Empty);
WorkflowQueuingService qService = parentContext.GetService <WorkflowQueuingService>();
WorkflowQueue wfQueue = null;
try
{
wfQueue = qService.GetWorkflowQueue(this.SubscriptionID);
}
catch
{
// If the queue no longer exists, eat the exception, we clear the subscription id later.
}
if (wfQueue != null && wfQueue.Count != 0)
{
wfQueue.Dequeue();
}
// WinOE
Activity root = parentContext.Activity;
while (root.Parent != null)
{
root = root.Parent;
}
TimerEventSubscriptionCollection timers = (TimerEventSubscriptionCollection)root.GetValue(TimerEventSubscriptionCollection.TimerCollectionProperty);
Debug.Assert(timers != null, "TimerEventSubscriptionCollection on root activity should never be null, but it was");
timers.Remove(this.SubscriptionID);
if (wfQueue != null)
{
wfQueue.UnregisterForQueueItemAvailable(parentEventHandler);
qService.DeleteWorkflowQueue(this.SubscriptionID);
}
this.SubscriptionID = Guid.Empty;
}
internal static object DequeueMessage(IComparable queueId, WorkflowQueuingService queueSvcs, Activity activity, out WorkflowQueue queue)
{
object obj2 = null;
queue = queueSvcs.GetWorkflowQueue(queueId);
if (queue.Count != 0)
{
obj2 = queue.Dequeue();
if (obj2 == null)
{
throw new ArgumentException(SR.GetString("Error_InvalidEventMessage", new object[] { activity.QualifiedName }));
}
}
return(obj2);
}
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e)
{
ActivityExecutionContext executionContext = sender as ActivityExecutionContext;
WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>();
WorkflowQueue queue = queueService.GetWorkflowQueue(e.QueueName);
if (queue.Count > 0)
{
object item = queue.Dequeue();
ProcessQueueItem(executionContext, item);
queue.UnregisterForQueueItemAvailable(this);
// run all Activities
base.Execute(executionContext);
}
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>();
WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
SetStateEventArgs eventArgs = workflowQueue.Dequeue() as SetStateEventArgs;
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
if (currentState == null)
{
throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState());
}
StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
SetStateAction action = new SetStateAction(currentState.QualifiedName, eventArgs.TargetStateName);
Debug.Assert(!executionState.HasEnqueuedActions);
executionState.EnqueueAction(action);
executionState.ProcessActions(context);
}
void IEventActivity.Unsubscribe(ActivityExecutionContext parentContext, IActivityEventListener <QueueEventArgs> parentEventHandler)
{
if (parentContext == null)
{
throw new ArgumentNullException("parentContext");
}
if (parentEventHandler == null)
{
throw new ArgumentNullException("parentEventHandler");
}
WorkflowQueuingService service = parentContext.GetService <WorkflowQueuingService>();
WorkflowQueue workflowQueue = null;
try
{
workflowQueue = service.GetWorkflowQueue(this.SubscriptionID);
}
catch
{
}
if ((workflowQueue != null) && (workflowQueue.Count != 0))
{
workflowQueue.Dequeue();
}
Activity parent = parentContext.Activity;
while (parent.Parent != null)
{
parent = parent.Parent;
}
((TimerEventSubscriptionCollection)parent.GetValue(TimerEventSubscriptionCollection.TimerCollectionProperty)).Remove(this.SubscriptionID);
if (workflowQueue != null)
{
workflowQueue.UnregisterForQueueItemAvailable(parentEventHandler);
service.DeleteWorkflowQueue(this.SubscriptionID);
}
this.SubscriptionID = Guid.Empty;
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>();
WorkflowQueue queue = queueService.GetWorkflowQueue(_queueName);
queue.RegisterForQueueItemAvailable(this, this.QualifiedName);
if (queue.Count > 0)
{
object item = queue.Dequeue();
ProcessQueueItem(executionContext, item);
queue.UnregisterForQueueItemAvailable(this);
// run all Activities
return(base.Execute(executionContext));
}
return(ActivityExecutionStatus.Executing);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (this.Fault == null)
{
throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, SR.Error_PropertyNotSet, FaultProperty.Name));
}
WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>();
// fire event
this.RaiseEvent(WebServiceFaultActivity.SendingFaultEvent, this, EventArgs.Empty);
WebServiceInputActivity webservicereceive = this.GetActivityByName(this.InputActivityName) as WebServiceInputActivity;
IComparable queueId = new EventQueueName(webservicereceive.InterfaceType, webservicereceive.MethodName, webservicereceive.QualifiedName);
Debug.Assert(queueService.Exists(queueId));
IMethodResponseMessage responseMessage = null;
WorkflowQueue queue = queueService.GetWorkflowQueue(queueId);
if (queue.Count != 0)
{
responseMessage = queue.Dequeue() as IMethodResponseMessage;
}
System.Diagnostics.Debug.Assert(responseMessage != null);
// populate exception & reset the waiting thread
responseMessage.SendException(this.Fault);
return(ActivityExecutionStatus.Closed);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>();
// fire event
this.RaiseEvent(WebServiceOutputActivity.SendingOutputEvent, this, EventArgs.Empty);
WebServiceInputActivity webservicereceive = this.GetActivityByName(this.InputActivityName) as WebServiceInputActivity;
if (webservicereceive == null)
{
Activity parent = this.Parent;
while (parent != null)
{
//typically if defined inside a custom activity
string qualifiedName = parent.QualifiedName + "." + this.InputActivityName;
webservicereceive = this.GetActivityByName(qualifiedName) as WebServiceInputActivity;
if (webservicereceive != null)
{
break;
}
parent = this.Parent;
}
}
if (webservicereceive == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_CannotResolveWebServiceInput, this.QualifiedName, this.InputActivityName));
}
IComparable queueId = new EventQueueName(webservicereceive.InterfaceType, webservicereceive.MethodName, webservicereceive.QualifiedName);
MethodInfo mInfo = webservicereceive.InterfaceType.GetMethod(webservicereceive.MethodName);
if (!queueService.Exists(queueId))
{
// determine if no response is required,
// compiler did not catch it, do the runtime check and return
if (mInfo.ReturnType == typeof(void))
{
return(ActivityExecutionStatus.Closed);
}
bool isresponseRequired = false;
foreach (ParameterInfo formalParameter in mInfo.GetParameters())
{
if (formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut))
{
isresponseRequired = true;
}
}
if (isresponseRequired)
{
return(ActivityExecutionStatus.Closed);
}
}
if (!queueService.Exists(queueId))
{
throw new InvalidOperationException(SR.GetString(SR.Error_WebServiceInputNotProcessed, webservicereceive.QualifiedName));
}
IMethodResponseMessage responseMessage = null;
WorkflowQueue queue = queueService.GetWorkflowQueue(queueId);
if (queue.Count != 0)
{
responseMessage = queue.Dequeue() as IMethodResponseMessage;
}
IMethodMessage message = responseMessage as IMethodMessage;
WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings;
ArrayList outArgs = new ArrayList();
// populate result
if (this.ParameterBindings.Contains("(ReturnValue)"))
{
WorkflowParameterBinding retBind = this.ParameterBindings["(ReturnValue)"];
if (retBind != null)
{
outArgs.Add(retBind.Value);
}
}
foreach (ParameterInfo formalParameter in mInfo.GetParameters())
{
// update out and byref values
if (formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut))
{
WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];
outArgs.Add(binding.Value);
}
}
// reset the waiting thread
responseMessage.SendResponse(outArgs);
return(ActivityExecutionStatus.Closed);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
WorkflowQueuingService service = executionContext.GetService <WorkflowQueuingService>();
base.RaiseEvent(SendingOutputEvent, this, EventArgs.Empty);
WebServiceInputActivity activityByName = base.GetActivityByName(this.InputActivityName) as WebServiceInputActivity;
if (activityByName == null)
{
for (Activity activity2 = base.Parent; activity2 != null; activity2 = base.Parent)
{
string activityQualifiedName = activity2.QualifiedName + "." + this.InputActivityName;
activityByName = base.GetActivityByName(activityQualifiedName) as WebServiceInputActivity;
if (activityByName != null)
{
break;
}
}
}
if (activityByName == null)
{
throw new InvalidOperationException(SR.GetString("Error_CannotResolveWebServiceInput", new object[] { base.QualifiedName, this.InputActivityName }));
}
IComparable queueName = new EventQueueName(activityByName.InterfaceType, activityByName.MethodName, activityByName.QualifiedName);
MethodInfo method = activityByName.InterfaceType.GetMethod(activityByName.MethodName);
if (!service.Exists(queueName))
{
if (method.ReturnType == typeof(void))
{
return(ActivityExecutionStatus.Closed);
}
bool flag = false;
foreach (ParameterInfo info2 in method.GetParameters())
{
if (info2.ParameterType.IsByRef || (info2.IsIn && info2.IsOut))
{
flag = true;
}
}
if (flag)
{
return(ActivityExecutionStatus.Closed);
}
}
if (!service.Exists(queueName))
{
throw new InvalidOperationException(SR.GetString("Error_WebServiceInputNotProcessed", new object[] { activityByName.QualifiedName }));
}
IMethodResponseMessage message = null;
WorkflowQueue workflowQueue = service.GetWorkflowQueue(queueName);
if (workflowQueue.Count != 0)
{
message = workflowQueue.Dequeue() as IMethodResponseMessage;
}
WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings;
ArrayList outArgs = new ArrayList();
if (this.ParameterBindings.Contains("(ReturnValue)"))
{
WorkflowParameterBinding binding = this.ParameterBindings["(ReturnValue)"];
if (binding != null)
{
outArgs.Add(binding.Value);
}
}
foreach (ParameterInfo info3 in method.GetParameters())
{
if (info3.ParameterType.IsByRef || (info3.IsIn && info3.IsOut))
{
WorkflowParameterBinding binding2 = parameterBindings[info3.Name];
outArgs.Add(binding2.Value);
}
}
message.SendResponse(outArgs);
return(ActivityExecutionStatus.Closed);
}
