protected override ActivityExecutionStatus Execute(ActivityExecutionContext aec)
{
//get the services needed
//custom service to run the workflow
CallWorkflowService ws = aec.GetService<CallWorkflowService>();
//Queuing service to setup the queue so the service can "callback"
WorkflowQueuingService qs = aec.GetService<WorkflowQueuingService>();
//create the queue the service can call back on when the child workflow is done
//you might want the queuename to be something different
string qn = String.Format("{0}:{1}:{2}", this.WorkflowInstanceId.ToString(), Type.Name, this.Name);
WorkflowQueue q = qs.CreateWorkflowQueue(qn, false);
q.QueueItemAvailable += new EventHandler<QueueEventArgs>(q_QueueItemAvailable);
//copy the params to a new collection
Dictionary<string, object> inparams = new Dictionary<string, object>();
foreach (WorkflowParameterBinding bp in this.Parameters)
{
PropertyInfo pi = Type.GetProperty(bp.ParameterName);
if(pi.CanWrite)
inparams.Add(bp.ParameterName, bp.Value);
}
//ask the service to start the workflow
ws.StartWorkflow(Type, inparams, this.WorkflowInstanceId, qn);
return ActivityExecutionStatus.Executing;
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
throw new ArgumentNullException("executionContext");
Type type = typeof(IInvokerLocalService);
object obj = executionContext.GetService(type);
if (obj == null)
throw new InvalidOperationException("IInvokerLocalService not found");
// pre-processing
base.RaiseEvent(ReturnActivity.InvokingEvent, this, EventArgs.Empty);
this.OnInvoking(EventArgs.Empty);
// return object
object returnValue = null;
if (this.ConnectorActivityName != "(None)")
{
returnValue = this.Parameters.Contains("(ReturnValue)") ? this.Parameters["(ReturnValue)"].GetValue(WorkflowParameterBinding.ValueProperty) : null;
}
// fire and forget in sync manner
object[] args = new object[2] { this.WorkflowInstanceId, returnValue };
type.InvokeMember("RaiseResponseEvent", BindingFlags.InvokeMethod, null, obj, args);
return ActivityExecutionStatus.Closed;
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ExternalRuleSetService.ExternalRuleSetService ruleSetService = context.GetService<ExternalRuleSetService.ExternalRuleSetService>();
if (ruleSetService != null)
{
RuleSet ruleSet = ruleSetService.GetRuleSet(new RuleSetInfo(this.RuleSetName, this.MajorVersion, this.MinorVersion));
if (ruleSet != null)
{
Activity targetActivity = this.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
ruleSet.Execute(execution);
}
}
else
{
throw new InvalidOperationException("A RuleSetService must be configured on the host to use the PolicyFromService activity.");
}
return ActivityExecutionStatus.Closed;
}
internal void DeleteQueue(ActivityExecutionContext context)
{
if (StateMachineHelpers.IsRootExecutionContext(context))
{
WorkflowQueuingService service = context.GetService<WorkflowQueuingService>();
service.GetWorkflowQueue("SetStateQueue");
service.DeleteWorkflowQueue("SetStateQueue");
}
}
internal void CreateQueue(ActivityExecutionContext context)
{
if (StateMachineHelpers.IsRootExecutionContext(context))
{
WorkflowQueuingService service = context.GetService<WorkflowQueuingService>();
MessageEventSubscription subscription = new MessageEventSubscription("SetStateQueue", this._instanceId);
service.CreateWorkflowQueue("SetStateQueue", true);
base.SubscriptionId = subscription.SubscriptionId;
}
}
private void DeleteSubscription(ActivityExecutionContext context)
{
if (this.queueName != null)
{
WorkflowQueuingService service = context.GetService <WorkflowQueuingService>();
if (this.queueCreator)
{
service.DeleteWorkflowQueue(this.queueName);
}
if (this.eventHandler == null)
{
WorkflowSubscriptionService service2 = context.GetService <WorkflowSubscriptionService>();
if (service2 != null)
{
service2.DeleteSubscription(this.subscriptionId);
}
WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationTokenInvalidatedHandler subscription deleted SubId {0} QueueId {1}", new object[] { this.subscriptionId, this.queueName });
}
}
}
internal static WorkflowQueue GetWorkflowQueue(ActivityExecutionContext context, IComparable queueName)
{
WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>();
if (workflowQueuingService.Exists(queueName))
{
WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(queueName);
return(workflowQueue);
}
return(null);
}
private void CreateSubscription(Guid instanceId, ActivityExecutionContext context, ICollection <CorrelationProperty> correlationValues)
{
WorkflowQueuingService service = context.GetService <WorkflowQueuingService>();
EventQueueName queueName = new EventQueueName(this.interfaceType, this.followerOperation, correlationValues);
WorkflowQueue workflowQueue = null;
if (!service.Exists(queueName))
{
WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationTokenInvalidatedHandler: creating q {0} ", new object[] { queueName.GetHashCode() });
workflowQueue = service.CreateWorkflowQueue(queueName, true);
this.queueCreator = true;
}
else
{
workflowQueue = service.GetWorkflowQueue(queueName);
}
if (this.eventHandler != null)
{
workflowQueue.RegisterForQueueItemAvailable(this.eventHandler);
}
WorkflowSubscriptionService service2 = (WorkflowSubscriptionService)context.GetService(typeof(WorkflowSubscriptionService));
MessageEventSubscription subscription = new MessageEventSubscription(queueName, instanceId);
this.queueName = queueName;
this.subscriptionId = subscription.SubscriptionId;
subscription.InterfaceType = this.interfaceType;
subscription.MethodName = this.followerOperation;
this.interfaceType = null;
this.followerOperation = null;
if (correlationValues != null)
{
foreach (CorrelationProperty property in correlationValues)
{
subscription.CorrelationProperties.Add(property);
}
}
if ((this.eventHandler == null) && (service2 != null))
{
service2.CreateSubscription(subscription);
}
}
private WorkflowQueue CreateQueue(ActivityExecutionContext context)
{
Console.WriteLine("CreateQueue");
WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>();
if (!qService.Exists(this.QueueName))
{
qService.CreateWorkflowQueue(this.QueueName, true);
}
return(qService.GetWorkflowQueue(this.QueueName));
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.RaiseEvent(PolicyFromService.BeforePolicyAppliedEvent, this, new EventArgs());
ExternalRuleSetService ruleSetService = context.GetService <ExternalRuleSetService>();
if (ruleSetService != null)
{
RuleSet ruleSet = Cache.Instance.Bag[this.RuleSetName + this.MajorVersion + this.MinorVersion] as RuleSet;
if (ruleSet == null)
{
ruleSet = ruleSetService.GetRuleSet(new RuleSetInfo(this.RuleSetName, this.MajorVersion, this.MinorVersion));
Cache.Instance.Bag.Add(this.RuleSetName + this.MajorVersion + this.MinorVersion, ruleSet);
}
if (ruleSet != null)
{
Activity targetActivity = this.GetRootWorkflow(this.Parent);
RuleValidation validation = new RuleValidation(targetActivity.GetType(), null);
RuleExecution execution = new RuleExecution(validation, targetActivity, context);
try
{
Dictionary <string, object> param = new Dictionary <string, object>();
param.Add("rulesetname", string.Format("{0}.{1}.{2}", ruleSet.Name, this.MajorVersion, this.MinorVersion));
ruleSet.Execute(execution);
}
catch (Exception ex)
{
Trace.TraceError(ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine + ex.InnerException);
if (!Information.IsSilientBusinessRuleError)
{
throw new Exception(ex.Message, ex.InnerException);
}
string mapId = Guid.NewGuid().ToString();
this.ErrorMessage = string.Format("A critical error occurred while executing rule {0}. MapId:{1}", ruleSet.Name, mapId);
PrintRuleSetTraceInformation(mapId, ruleSet, validation);
}
base.RaiseEvent(PolicyFromService.AfterPolicyAppliedEvent, this, EventArgs.Empty);
}
}
else
{
throw new InvalidOperationException("A RuleSetService must be configured on the host to use the PolicyFromService activity.");
}
return(ActivityExecutionStatus.Closed);
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
SetStateEventArgs args = context.GetService<WorkflowQueuingService>().GetWorkflowQueue("SetStateQueue").Dequeue() as SetStateEventArgs;
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
if (currentState == null)
{
throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState());
}
StateMachineExecutionState state = StateMachineExecutionState.Get(StateMachineHelpers.GetRootState((StateActivity) context.Activity));
SetStateAction action = new SetStateAction(currentState.QualifiedName, args.TargetStateName);
state.EnqueueAction(action);
state.ProcessActions(context);
}
// Handler when a queue item is available
private void OnQueueItemAvailable(object sender, QueueEventArgs args)
{
ActivityExecutionContext context = sender as ActivityExecutionContext;
WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>() as WorkflowQueuingService;
IComparable qName = this.Queue;
// Dequeue the item and remove the handler
if (TryDequeueAndComplete(context, qName))
{
qService.GetWorkflowQueue(qName).QueueItemAvailable -= this.OnQueueItemAvailable;
}
}
protected override ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception)
{
SPSecurity.RunWithElevatedPrivileges(delegate()
{
string errorMessage = string.Format("Error querying XML. {0}", exception.Message);
ISharePointService spService = (ISharePointService)executionContext.GetService(typeof(ISharePointService));
spService.LogToHistoryList(this.WorkflowInstanceId, SPWorkflowHistoryEventType.WorkflowError, -1, TimeSpan.MinValue, "Error",
errorMessage, String.Empty);
});
return(base.HandleFault(executionContext, exception));
}
protected override sealed ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
// Fire the Before Invoke Handler
base.RaiseEvent(OnBeforeInvokeEvent, this, EventArgs.Empty);
// Get reference to the transactional service from the context
AbstractTransactionService service = context.GetService<AbstractTransactionService>();
// Call a method on the service and pass the payload to it
service.DebitAmount(this.Amount);
// Return the status of the activity as closed
return ActivityExecutionStatus.Closed;
}
// Dequeue the item and then process the item
private bool TryDequeueAndComplete(ActivityExecutionContext context, IComparable queueName)
{
WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>() as WorkflowQueuingService;
IComparable qName = this.Queue;
if (qService.GetWorkflowQueue(qName).Count > 0)
{
this.Data = qService.GetWorkflowQueue(qName).Dequeue();
return(true);
}
return(false);
}
private void Compensate(ActivityExecutionContext activityExecutionContext)
{
var compensationService = activityExecutionContext.GetService <ICompensationService>();
if (string.IsNullOrWhiteSpace(CompensableActivityId))
{
compensationService.Compensate(activityExecutionContext, Exception, Message);
}
else
{
compensationService.Compensate(activityExecutionContext, CompensableActivityId, Exception, Message);
}
}
private void ProcessParameters(ActivityExecutionContext context, IMethodMessage message, Type interfaceType, string operation)
{
WorkflowParameterBindingCollection parameters = ParameterBindings;
if (parameters == null)
{
return;
}
//cache mInfo todo
MethodInfo mInfo = interfaceType.GetMethod(operation);
if (mInfo == null)
{
return;
}
int index = 0;
bool responseRequired = false;
foreach (ParameterInfo formalParameter in mInfo.GetParameters())
{
// populate in params, checking on IsIn alone is not sufficient
if (!(formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut)))
{
if (parameters.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameters[formalParameter.Name];
binding.Value = message.Args[index++];
}
}
else
{
responseRequired = true;
}
}
if (mInfo.ReturnType != typeof(void) || responseRequired)
{
// create queue entry {interface, operation and receive activity Id}
IComparable queueId = new EventQueueName(interfaceType, operation, QualifiedName);
// enqueue the message for sendresponse reply context
WorkflowQueuingService queuingService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
if (!queuingService.Exists(queueId))
{
queuingService.CreateWorkflowQueue(queueId, true);
}
queuingService.GetWorkflowQueue(queueId).Enqueue(message);
}
}
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;
}
protected override sealed ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
// Fire the Before Invoke Handler
base.RaiseEvent(OnBeforeInvokeEvent, this, EventArgs.Empty);
// Get reference to the transactional service from the context
AbstractTransactionService service = context.GetService <AbstractTransactionService>();
// Call a method on the service and pass the payload to it
service.CreditAmount(this.Amount);
// Return the status of the activity as closed
return(ActivityExecutionStatus.Closed);
}
protected override ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception)
{
string errorMessage = string.Format("Error Executing PowerShell Script. {0}", exception.Message);
ISharePointService spService = (ISharePointService)executionContext.GetService(typeof(ISharePointService));
spService.LogToHistoryList(this.WorkflowInstanceId, SPWorkflowHistoryEventType.WorkflowError, -1, TimeSpan.MinValue, "Error",
errorMessage, String.Empty);
EventLog.WriteEntry("PowerActivity", errorMessage, EventLogEntryType.Error);
errorMessage += Environment.NewLine + exception.StackTrace;
return(base.HandleFault(executionContext, exception));
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (this.InterfaceType == null)
{
throw new ArgumentException(
SR.GetString(SR.Error_MissingInterfaceType), "executionContext");
}
Type type = this.InterfaceType;
string methodName = this.MethodName;
object serviceValue = executionContext.GetService(type);
if (serviceValue == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_ServiceNotFound, this.InterfaceType));
}
this.RaiseEvent(MethodInvokingEvent, this, EventArgs.Empty);
OnMethodInvoking(EventArgs.Empty);
MethodInfo methodInfo = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);
ParameterModifier[] parameterModifiers = null;
object[] actualParameters = InvokeHelper.GetParameters(methodInfo, this.ParameterBindings, out parameterModifiers);
WorkflowParameterBinding resultBinding = null;
if (this.ParameterBindings.Contains("(ReturnValue)"))
{
resultBinding = this.ParameterBindings["(ReturnValue)"];
}
CorrelationService.InvalidateCorrelationToken(this, type, methodName, actualParameters);
object result = type.InvokeMember(this.MethodName, BindingFlags.InvokeMethod, new ExternalDataExchangeBinder(), serviceValue, actualParameters, parameterModifiers, null, null);
if (resultBinding != null)
{
resultBinding.Value = InvokeHelper.CloneOutboundValue(result, new BinaryFormatter(), "(ReturnValue)");
}
InvokeHelper.SaveOutRefParameters(actualParameters, methodInfo, this.ParameterBindings);
OnMethodInvoked(EventArgs.Empty);
return(ActivityExecutionStatus.Closed);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
{
List<string> ls = executionContext.GetService(typeof(List<string>)) as List<string>;
if (ls != null)
{
ls.Add("--------------------------归档-----------------------------------");
ls.Add("流程编号:" + Root().流程编号.ToString());
ls.Add("");
}
}
return base.Execute(executionContext);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
{
List <string> ls = executionContext.GetService(typeof(List <string>)) as List <string>;
if (ls != null)
{
ls.Add("--------------------------归档-----------------------------------");
ls.Add("流程编号:" + Root().流程编号.ToString());
ls.Add("");
}
}
return(base.Execute(executionContext));
}
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
Exception ex = o as Exception;
if (ex != null)
{
throw ex;
}
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();
///
SubWorkflowService ws = aec.GetService <SubWorkflowService>();
ws.OnFinishCallworkflowActivity(this.WorkflowInstanceId);
}
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
SetStateEventArgs args = context.GetService <WorkflowQueuingService>().GetWorkflowQueue("SetStateQueue").Dequeue() as SetStateEventArgs;
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
if (currentState == null)
{
throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState());
}
StateMachineExecutionState state = StateMachineExecutionState.Get(StateMachineHelpers.GetRootState((StateActivity)context.Activity));
SetStateAction action = new SetStateAction(currentState.QualifiedName, args.TargetStateName);
state.EnqueueAction(action);
state.ProcessActions(context);
}
internal void DeleteQueue(ActivityExecutionContext context)
{
if (!StateMachineHelpers.IsRootExecutionContext(context))
{
// we only subscribe to the set state event if
// we're at the root level. If this instance is
// being called, it is not possible to set the
// state from the host side directly
return;
}
WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>();
WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
workflowQueuingService.DeleteWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
}
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);
}
}
protected sealed override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
WorkflowQueuingService queueService = executionContext.GetService <WorkflowQueuingService>();
if (_queueName != null && queueService != null)
{
WorkflowQueue queue = queueService.GetWorkflowQueue(_queueName);
queue.UnregisterForQueueItemAvailable(this);
}
return(ActivityExecutionStatus.Closed);
}
private ActivityExecutionStatus ExecuteForActivity(ActivityExecutionContext context, Type interfaceType, string operation)
{
WorkflowQueuingService queueSvcs = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
IComparable queueId = new EventQueueName(interfaceType, operation);
if (queueId != null)
{
WorkflowQueue queue;
object msg = InboundActivityHelper.DequeueMessage(queueId, queueSvcs, this, out queue);
if (msg != null)
{
this.ProcessMessage(context, msg, interfaceType, operation);
return(ActivityExecutionStatus.Closed);
}
}
return(ActivityExecutionStatus.Executing);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
this.RaiseEvent(InvokeWorkflow.BeforeInvokedEvent, this, new EventArgs());
if (this.TargetWorkflow == null)
{
throw new InvalidOperationException("TargetWorkflow property must be set to a valid Type that derives from Activity.");
}
IStartWorkflow startWorkflow = executionContext.GetService(typeof(IStartWorkflow)) as IStartWorkflow;
this.InstanceId = startWorkflow.StartWorkflow(this.TargetWorkflow, this.Parameters);
//base.SetValue(InstanceIdProperty, instanceId);
this.RaiseEvent(InvokeWorkflow.AfterInvokedEvent, this, new EventArgs());
return(ActivityExecutionStatus.Closed);
}
protected override ActivityExecutionStatus Execute(
ActivityExecutionContext executionContext)
{
IAccountServices accountServices =
executionContext.GetService <IAccountServices>();
if (accountServices == null)
{
//we have a big problem
throw new InvalidOperationException(
"Unable to retrieve IAccountServices from runtime");
}
//apply the adjustment to the account
Account = accountServices.AdjustBalance(Id, Adjustment);
return(base.Execute(executionContext));
}
internal static ActivityExecutionStatus ExecuteForActivity(HandleExternalEventActivity activity, ActivityExecutionContext context, Type interfaceType, string operation, out object[] args)
{
WorkflowQueuingService queueSvcs = (WorkflowQueuingService) context.GetService(typeof(WorkflowQueuingService));
args = null;
IComparable queueId = CorrelationService.ResolveQueueName(activity, interfaceType, operation);
if (queueId != null)
{
WorkflowQueue queue;
object msg = DequeueMessage(queueId, queueSvcs, activity, out queue);
CorrelationService.UninitializeFollowers(interfaceType, operation, queue);
if (msg != null)
{
args = ProcessEvent(activity, context, msg, interfaceType, operation);
return ActivityExecutionStatus.Closed;
}
}
return ActivityExecutionStatus.Executing;
}
internal static ActivityExecutionStatus ExecuteForActivity(HandleExternalEventActivity activity, ActivityExecutionContext context, Type interfaceType, string operation, out object[] args)
{
WorkflowQueuingService queueSvcs = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
args = null;
IComparable queueId = CorrelationService.ResolveQueueName(activity, interfaceType, operation);
if (queueId != null)
{
WorkflowQueue queue;
object msg = DequeueMessage(queueId, queueSvcs, activity, out queue);
CorrelationService.UninitializeFollowers(interfaceType, operation, queue);
if (msg != null)
{
args = ProcessEvent(activity, context, msg, interfaceType, operation);
return(ActivityExecutionStatus.Closed);
}
}
return(ActivityExecutionStatus.Executing);
}
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);
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
ActivityExecutionStatus status;
ActivityExecutionContextManager manager = executionContext.ExecutionContextManager;
ReadOnlyCollection <ActivityExecutionContext> contexts = manager.ExecutionContexts;
Console.WriteLine("***ourCodeActivity.Execute {0}", contexts.Count);
IComparable queue_name = "our_queue";
WorkflowQueuingService qService = executionContext.GetService <WorkflowQueuingService> ();
if (!qService.Exists(queue_name))
{
Console.WriteLine("CreatingQue");
qService.CreateWorkflowQueue(queue_name, true);
}
status = base.Execute(executionContext);
return(status);
}
private void ProcessParameters(ActivityExecutionContext context, IMethodMessage message, Type interfaceType, string operation)
{
WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings;
if (parameterBindings != null)
{
MethodInfo method = interfaceType.GetMethod(operation);
if (method != null)
{
int num = 0;
bool flag = false;
foreach (ParameterInfo info2 in method.GetParameters())
{
if (!info2.ParameterType.IsByRef && (!info2.IsIn || !info2.IsOut))
{
if (parameterBindings.Contains(info2.Name))
{
WorkflowParameterBinding binding = parameterBindings[info2.Name];
binding.Value = message.Args[num++];
}
}
else
{
flag = true;
}
}
if ((method.ReturnType != typeof(void)) || flag)
{
IComparable queueName = new EventQueueName(interfaceType, operation, base.QualifiedName);
WorkflowQueuingService service = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
if (!service.Exists(queueName))
{
service.CreateWorkflowQueue(queueName, true);
}
service.GetWorkflowQueue(queueName).Enqueue(message);
}
}
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
//WorkflowQueuingService is a component that allows access to queue items
//enqueued to a particular workflow instance
// Items are submitted to a workflow instance from the host using the
// EnqueueItem method call on the workflowinstance
WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>() as WorkflowQueuingService;
// The Queue name is in the activity context and specified in the Enqueue item call
IComparable qName = this.Queue;
//Try to dequeue if there are any items available
// Register the handler OnQueueItemAvailable when a item is queued
if (!TryDequeueAndComplete(context, qName))
{
qService.GetWorkflowQueue(qName).QueueItemAvailable += this.OnQueueItemAvailable;
return(ActivityExecutionStatus.Executing);
}
return(ActivityExecutionStatus.Closed);
}
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;
}
void IEventActivity.Subscribe(ActivityExecutionContext parentContext, IActivityEventListener <QueueEventArgs> parentEventHandler)
{
if (parentContext == null)
{
throw new ArgumentNullException("parentContext");
}
if (parentEventHandler == null)
{
throw new ArgumentNullException("parentEventHandler");
}
this.IsInEventActivityMode = true;
base.RaiseEvent(DelayActivity.InitializeTimeoutDurationEvent, this, EventArgs.Empty);
TimeSpan timeSpan = this.TimeoutDuration;
DateTime timeOut = DateTime.UtcNow + timeSpan;
WorkflowQueuingService qService = parentContext.GetService <WorkflowQueuingService>();
IComparable queueName = ((IEventActivity)this).QueueName;
TimerEventSubscription timerSub = new TimerEventSubscription((Guid)queueName, this.WorkflowInstanceId, timeOut);
WorkflowQueue queue = qService.CreateWorkflowQueue(queueName, false);
queue.RegisterForQueueItemAvailable(parentEventHandler, this.QualifiedName);
this.SubscriptionID = timerSub.SubscriptionId;
Activity root = this;
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.Add(timerSub);
}
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;
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (this.InterfaceType == null)
{
throw new ArgumentException(SR.GetString("Error_MissingInterfaceType"), "executionContext");
}
Type interfaceType = this.InterfaceType;
string methodName = this.MethodName;
object service = executionContext.GetService(interfaceType);
if (service == null)
{
throw new InvalidOperationException(SR.GetString("Error_ServiceNotFound", new object[] { this.InterfaceType }));
}
base.RaiseEvent(MethodInvokingEvent, this, EventArgs.Empty);
this.OnMethodInvoking(EventArgs.Empty);
MethodInfo method = interfaceType.GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
ParameterModifier[] parameterModifiers = null;
object[] messageArgs = InvokeHelper.GetParameters(method, this.ParameterBindings, out parameterModifiers);
WorkflowParameterBinding binding = null;
if (this.ParameterBindings.Contains("(ReturnValue)"))
{
binding = this.ParameterBindings["(ReturnValue)"];
}
CorrelationService.InvalidateCorrelationToken(this, interfaceType, methodName, messageArgs);
object source = interfaceType.InvokeMember(this.MethodName, BindingFlags.InvokeMethod, new ExternalDataExchangeBinder(), service, messageArgs, parameterModifiers, null, null);
if (binding != null)
{
binding.Value = InvokeHelper.CloneOutboundValue(source, new BinaryFormatter(), "(ReturnValue)");
}
InvokeHelper.SaveOutRefParameters(messageArgs, method, this.ParameterBindings);
this.OnMethodInvoked(EventArgs.Empty);
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;
}
internal static WorkflowQueue GetWorkflowQueue(ActivityExecutionContext context, IComparable queueName)
{
WorkflowQueuingService workflowQueuingService = context.GetService<WorkflowQueuingService>();
if (workflowQueuingService.Exists(queueName))
{
WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(queueName);
return workflowQueue;
}
return null;
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
throw new ArgumentNullException("executionContext");
// raise event
base.RaiseEvent(InvokeWorkflowActivity.InvokingEvent, this, EventArgs.Empty);
// collect the [in] parameters
Dictionary<string, object> namedArgumentValues = new Dictionary<string, object>();
foreach (WorkflowParameterBinding paramBinding in this.ParameterBindings)
namedArgumentValues.Add(paramBinding.ParameterName, paramBinding.Value);
IStartWorkflow workflowInvoker = executionContext.GetService(typeof(IStartWorkflow)) as IStartWorkflow;
if (workflowInvoker == null)
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(IStartWorkflow).FullName));
Guid instanceId = workflowInvoker.StartWorkflow(this.TargetWorkflow, namedArgumentValues);
if (instanceId == Guid.Empty)
throw new InvalidOperationException(SR.GetString(SR.Error_FailedToStartTheWorkflow));
this.SetInstanceId(instanceId);
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;
}
protected sealed override ActivityExecutionStatus Execute (ActivityExecutionContext executionContext)
{
object[] parameters;
object data = executionContext.GetService (InterfaceType);
MethodInfo invoke = InterfaceType.GetMethod (MethodName);
ParameterInfo[] pars = invoke.GetParameters ();
parameters = new object [pars.Length];
for (int i = 0; i < pars.Length; i++) {
ParameterBindings.Add (new WorkflowParameterBinding (pars[i].Name));
}
// User may set the ParameterBindings
OnMethodInvoking (new EventArgs ());
for (int i = 0; i < pars.Length; i++) {
parameters[i] = (ParameterBindings [pars[i].Name]).Value;
}
InterfaceType.InvokeMember (MethodName,
BindingFlags.InvokeMethod,
null, data,
parameters);
OnMethodInvoked (new EventArgs ());
NeedsExecution = false;
return ActivityExecutionStatus.Closed;
}
internal static void AddCommentWorkflowHistory(string message, ActivityExecutionContext context, Guid wrkflowInstanceID)
{
ISharePointService service = (ISharePointService)context.GetService(typeof(ISharePointService));
if (service == null)
{
throw new InvalidOperationException();
}
service.LogToHistoryList(wrkflowInstanceID, SPWorkflowHistoryEventType.None, 0, TimeSpan.MinValue, "", message, message);
}
internal void Unsubscribe(ActivityExecutionContext context)
{
context.GetService<WorkflowQueuingService>().GetWorkflowQueue("SetStateQueue").UnregisterForQueueItemAvailable(this);
}
public WorkflowHistoryTraceListener(ActivityExecutionContext context, Guid workflowInstanceID)
{
service = (ISharePointService)context.GetService(typeof(ISharePointService));
if (service == null)
{
throw new InvalidOperationException();
}
this.workflowInstanceID = workflowInstanceID;
}
/// <summary>
/// logs exceptions to sharepoint's workflow history log
/// </summary>
/// <param name="e"></param>
/// <param name="context"></param>
internal static void LogExceptionToWorkflowHistory(Exception e, ActivityExecutionContext context, Guid wrkflowInstanceID)
{
ISharePointService service = (ISharePointService)context.GetService(typeof(ISharePointService));
if (service == null)
{
throw new InvalidOperationException();
}
service.LogToHistoryList(wrkflowInstanceID, SPWorkflowHistoryEventType.WorkflowError, 0, TimeSpan.MinValue, "Error", e.ToString(), "");
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context)
{
//WorkflowQueuingService is a component that allows access to queue items
//enqueued to a particular workflow instance
// Items are submitted to a workflow instance from the host using the
// EnqueueItem method call on the workflowinstance
WorkflowQueuingService qService = context.GetService<WorkflowQueuingService>() as WorkflowQueuingService;
// The Queue name is in the activity context and specified in the Enqueue item call
IComparable qName = this.Queue;
//Try to dequeue if there are any items available
// Register the handler OnQueueItemAvailable when a item is queued
if (!TryDequeueAndComplete(context, qName))
{
qService.GetWorkflowQueue(qName).QueueItemAvailable += this.OnQueueItemAvailable;
return ActivityExecutionStatus.Executing;
}
return ActivityExecutionStatus.Closed;
}
internal static ChannelTicket Take(ActivityExecutionContext executionContext, Guid workflowId, LogicalChannel logicalChannel)
{
if (executionContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("executionContext");
}
if (workflowId == Guid.Empty)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("workflowId",
SR2.GetString(SR2.Error_Cache_InvalidWorkflowId));
}
if (logicalChannel == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("logicalChannel");
}
ChannelManagerService channelManager = executionContext.GetService<ChannelManagerService>();
ChannelTicket channel;
if (channelManager != null)
{
channel = channelManager.TakeChannel(workflowId, logicalChannel);
}
else
{
channel = ChannelManagerService.CreateTransientChannel(logicalChannel);
}
return channel;
}
protected IComparable SetTimer (ActivityExecutionContext executionContext, DateTime expiresAt)
{
#if RUNTIME_DEP
TimerEventSubscription te;
WorkflowQueue queue;
te = new TimerEventSubscription (executionContext.ExecutionContextManager.Workflow.InstanceId,
expiresAt);
WorkflowQueuingService qService = executionContext.GetService <WorkflowQueuingService> ();
queue = qService.CreateWorkflowQueue (te.QueueName, true);
queue.QueueItemArrived += OnQueueTimerItemArrived;
executionContext.ExecutionContextManager.Workflow.TimerEventSubscriptionCollection.Add (te);
return te.QueueName;
#else
return null;
#endif
}
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;
}
// Dequeue the item and then process the item
private bool TryDequeueAndComplete(ActivityExecutionContext context, IComparable queueName)
{
WorkflowQueuingService qService = context.GetService<WorkflowQueuingService>() as WorkflowQueuingService;
IComparable qName = this.Queue;
if (qService.GetWorkflowQueue(qName).Count > 0)
{
this.Data = qService.GetWorkflowQueue(qName).Dequeue();
return true;
}
return false;
}
protected sealed override ActivityExecutionStatus Execute (ActivityExecutionContext executionContext)
{
ActivityExecutionStatus status;
ActivityExecutionContextManager manager = executionContext.ExecutionContextManager;
ReadOnlyCollection <ActivityExecutionContext> contexts = manager.ExecutionContexts;
Console.WriteLine ("***ourCodeActivity.Execute {0}", contexts.Count);
IComparable queue_name = "our_queue";
WorkflowQueuingService qService = executionContext.GetService<WorkflowQueuingService> ();
if (!qService.Exists (queue_name)) {
Console.WriteLine ("CreatingQue");
qService.CreateWorkflowQueue (queue_name, true);
}
status = base.Execute (executionContext);
return status;
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
throw new ArgumentNullException("executionContext");
if (this.InterfaceType == null)
throw new ArgumentException(
SR.GetString(SR.Error_MissingInterfaceType), "executionContext");
Type type = this.InterfaceType;
string methodName = this.MethodName;
object serviceValue = executionContext.GetService(type);
if (serviceValue == null)
throw new InvalidOperationException(SR.GetString(SR.Error_ServiceNotFound, this.InterfaceType));
this.RaiseEvent(MethodInvokingEvent, this, EventArgs.Empty);
OnMethodInvoking(EventArgs.Empty);
MethodInfo methodInfo = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);
ParameterModifier[] parameterModifiers = null;
object[] actualParameters = InvokeHelper.GetParameters(methodInfo, this.ParameterBindings, out parameterModifiers);
WorkflowParameterBinding resultBinding = null;
if (this.ParameterBindings.Contains("(ReturnValue)"))
resultBinding = this.ParameterBindings["(ReturnValue)"];
CorrelationService.InvalidateCorrelationToken(this, type, methodName, actualParameters);
object result = type.InvokeMember(this.MethodName, BindingFlags.InvokeMethod, new ExternalDataExchangeBinder(), serviceValue, actualParameters, parameterModifiers, null, null);
if (resultBinding != null)
resultBinding.Value = InvokeHelper.CloneOutboundValue(result, new BinaryFormatter(), "(ReturnValue)");
InvokeHelper.SaveOutRefParameters(actualParameters, methodInfo, this.ParameterBindings);
OnMethodInvoked(EventArgs.Empty);
return ActivityExecutionStatus.Closed;
}
