public void TestConstructorNullException()
{
WorkflowParameterBindingCollection wc = new WorkflowParameterBindingCollection(new ParallelActivity());
WorkflowParameterBinding pb1 = new WorkflowParameterBinding();
wc.Add(pb1);
}
protected override void OnActivityChanged(ActivityChangedEventArgs e)
{
base.OnActivityChanged(e);
if (e.Member != null)
{
if (string.Equals(e.Member.Name, "TargetWorkflow", StringComparison.Ordinal))
{
//We need to clear the parameter bindings if target workflow type changes
if (e.OldValue != e.NewValue && Activity != null)
{
PropertyInfo parameterProperty = Activity.GetType().GetProperty("ParameterBindings", BindingFlags.Instance | BindingFlags.Public);
if (parameterProperty != null)
{
WorkflowParameterBindingCollection bindings = parameterProperty.GetValue(Activity, null) as WorkflowParameterBindingCollection;
if (bindings != null)
{
bindings.Clear();
}
}
}
RefreshTargetWorkflowType();
}
}
}
private static bool ProcessEventParameters(WorkflowParameterBindingCollection parameters, IMethodMessage message, Type interfaceType, string operation)
{
bool isKnownSignature = false;
if (parameters == null)
return isKnownSignature;
EventInfo eventInfo = interfaceType.GetEvent(operation);
MethodInfo methodInfo = eventInfo.EventHandlerType.GetMethod("Invoke");
int index = 0;
foreach (ParameterInfo formalParameter in methodInfo.GetParameters())
{
if ((typeof(ExternalDataEventArgs).IsAssignableFrom(formalParameter.ParameterType)))
{
if (index == 1)
isKnownSignature = true;
}
if (parameters.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameters[formalParameter.Name];
binding.Value = message.Args[index];
}
index++;
}
return isKnownSignature;
}
public object[] GetInputs(SendActivity activity, WorkflowParameterBindingCollection bindings)
{
if (activity == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("activity");
}
object[] inputs = new object[this.parameterCount];
if (inputParameters.Count > 0)
{
for (int index = 0; index < inputParameters.Count; index++)
{
KeyValuePair <int, string> parameterInfo = inputParameters[index];
if (bindings.Contains(parameterInfo.Value))
{
inputs[parameterInfo.Key] = bindings[parameterInfo.Value].Value;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ParameterBindingMissing,
parameterInfo.Value,
this.operationName,
activity.Name)));
}
}
}
return(inputs);
}
private static bool ProcessEventParameters(WorkflowParameterBindingCollection parameters, IMethodMessage message, Type interfaceType, string operation)
{
bool isKnownSignature = false;
if (parameters == null)
{
return(isKnownSignature);
}
EventInfo eventInfo = interfaceType.GetEvent(operation);
MethodInfo methodInfo = eventInfo.EventHandlerType.GetMethod("Invoke");
int index = 0;
foreach (ParameterInfo formalParameter in methodInfo.GetParameters())
{
if ((typeof(ExternalDataEventArgs).IsAssignableFrom(formalParameter.ParameterType)))
{
if (index == 1)
{
isKnownSignature = true;
}
}
if (parameters.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameters[formalParameter.Name];
binding.Value = message.Args[index];
}
index++;
}
return(isKnownSignature);
}
public override void SetValue(object component, object value)
{
if (component != null)
{
IServiceProvider site = MemberDescriptor.GetSite(component);
ComponentChangeDispatcher dispatcher = (site != null) ? new ComponentChangeDispatcher(site, component, this) : null;
try
{
WorkflowParameterBindingCollection parameterBindings = this.GetParameterBindings(component);
if (parameterBindings != null)
{
string key = string.Empty;
if (this.Name.StartsWith("(Parameter) ", StringComparison.Ordinal))
{
key = this.Name.Substring("(Parameter) ".Length);
}
else
{
key = this.Name;
}
WorkflowParameterBinding item = null;
if (parameterBindings.Contains(key))
{
item = parameterBindings[key];
}
else
{
item = new WorkflowParameterBinding(key);
parameterBindings.Add(item);
}
if (value is ActivityBind)
{
item.SetBinding(WorkflowParameterBinding.ValueProperty, value as ActivityBind);
}
else
{
item.SetValue(WorkflowParameterBinding.ValueProperty, value);
}
this.OnValueChanged(component, EventArgs.Empty);
}
}
catch (Exception exception)
{
if ((exception is TargetInvocationException) && (exception.InnerException != null))
{
throw exception.InnerException;
}
throw exception;
}
finally
{
if (dispatcher != null)
{
dispatcher.Dispose();
}
}
}
}
private WorkflowParameterBindingCollection GetParameterBindings(object component)
{
WorkflowParameterBindingCollection bindings = null;
if (component.GetType().GetProperty("ParameterBindings", BindingFlags.ExactBinding | BindingFlags.GetProperty | BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance, null, typeof(WorkflowParameterBindingCollection), new Type[0], new ParameterModifier[0]) != null)
{
bindings = component.GetType().InvokeMember("ParameterBindings", BindingFlags.ExactBinding | BindingFlags.GetProperty | BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance, null, component, new object[0], CultureInfo.InvariantCulture) as WorkflowParameterBindingCollection;
}
return(bindings);
}
private WorkflowParameterBindingCollection GetParameterBindings(object component)
{
WorkflowParameterBindingCollection retVal = null;
MemberInfo memberInfo = component.GetType().GetProperty("ParameterBindings", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.ExactBinding, null, typeof(WorkflowParameterBindingCollection), new Type[] { }, new ParameterModifier[] { });
if (memberInfo != null)
{
retVal = component.GetType().InvokeMember("ParameterBindings", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.ExactBinding, null, component, new object[] { }, CultureInfo.InvariantCulture) as WorkflowParameterBindingCollection;
}
return(retVal);
}
protected virtual void ProcessQueueItem(ActivityExecutionContext executionContext, object item)
{
IMethodCallMessage message = item as IMethodCallMessage;
if (message == null)
{
Exception exception = message as Exception;
if (exception != null)
{
throw exception;
}
throw new InvalidOperationException("Invalid LocalServiceMessage");
}
else if (message.MethodName == this.MethodName)
{
// LogicalCallConetext
LCC.CopyFrom(message);
// roles
Helpers.ValidateRoles(this, message);
WorkflowParameterBindingCollection collection = this.Parameters;
if (collection != null)
{
int ii = 0;
MethodInfo mi = this.Type.GetMethod(this.MethodName);
if (mi != null)
{
foreach (ParameterInfo pi in mi.GetParameters())
{
if (!pi.ParameterType.IsByRef && (!pi.IsIn || !pi.IsOut))
{
if (collection.Contains(pi.Name))
{
WorkflowParameterBinding binding = collection[pi.Name];
binding.Value = message.InArgs[ii++];
}
}
}
}
}
// postprocessing
OnReceived(EventArgs.Empty);
base.RaiseEvent(OperationContractWorkflowBase.ReceivedEvent, this, EventArgs.Empty);
// done
return;
}
throw new InvalidOperationException("Invalid received MethodMessage");
}
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);
}
}
internal static void InitializeParameters(MethodInfo methodBase, WorkflowParameterBindingCollection parameterBindings)
{
foreach (ParameterInfo info in methodBase.GetParameters())
{
if (!parameterBindings.Contains(info.Name))
{
parameterBindings.Add(new WorkflowParameterBinding(info.Name));
}
}
if ((methodBase.ReturnType != typeof(void)) && !parameterBindings.Contains("(ReturnValue)"))
{
parameterBindings.Add(new WorkflowParameterBinding("(ReturnValue)"));
}
}
internal static void InitializeParameters(MethodInfo methodBase, WorkflowParameterBindingCollection parameterBindings)
{
ParameterInfo[] parameters = methodBase.GetParameters();
foreach (ParameterInfo parameter in parameters)
{
if (!parameterBindings.Contains(parameter.Name))
parameterBindings.Add(new WorkflowParameterBinding(parameter.Name));
}
if (methodBase.ReturnType != typeof(void))
{
if (!parameterBindings.Contains("(ReturnValue)"))
parameterBindings.Add(new WorkflowParameterBinding("(ReturnValue)"));
}
}
public override object GetValue(object component)
{
WorkflowParameterBindingCollection parameterBindings = this.GetParameterBindings(component);
string name = this.Name;
string key = name.StartsWith("(Parameter) ", StringComparison.Ordinal) ? name.Substring("(Parameter) ".Length) : name;
if ((parameterBindings == null) || !parameterBindings.Contains(key))
{
return(null);
}
if (parameterBindings[key].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
return(parameterBindings[key].GetBinding(WorkflowParameterBinding.ValueProperty));
}
return(parameterBindings[key].GetValue(WorkflowParameterBinding.ValueProperty));
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
ParameterInfo[] parameters = methodBase.GetParameters();
object[] objArray = new object[parameters.Length];
int index = 0;
foreach (ParameterInfo info in parameters)
{
if (parameterBindings.Contains(info.Name))
{
WorkflowParameterBinding binding = parameterBindings[info.Name];
objArray[index] = binding.Value;
}
index++;
}
return objArray;
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
ParameterInfo[] formalParameters = methodBase.GetParameters();
object[] actualParameters = new object[formalParameters.Length];
int index = 0;
foreach (ParameterInfo formalParameter in formalParameters)
{
if (parameterBindings.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];
actualParameters[index] = binding.Value;
}
index++;
}
return actualParameters;
}
public void TestAddRemove()
{
WorkflowParameterBindingCollection wc = new WorkflowParameterBindingCollection(new ParallelActivity());
WorkflowParameterBinding pb1 = new WorkflowParameterBinding("Name1");
WorkflowParameterBinding pb2 = new WorkflowParameterBinding("Name2");
WorkflowParameterBinding pb3 = new WorkflowParameterBinding("Name3");
wc.Add(pb1);
wc.Add(pb2);
wc.Add(pb3);
Assert.AreEqual(3, wc.Count, "C1#1");
Assert.AreEqual(pb1, wc[0], "C1#2");
Assert.AreEqual(pb2, wc[1], "C1#3");
Assert.AreEqual(pb3, wc[2], "C1#4");
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
ParameterInfo[] parameters = methodBase.GetParameters();
object[] objArray = new object[parameters.Length];
int index = 0;
foreach (ParameterInfo info in parameters)
{
if (parameterBindings.Contains(info.Name))
{
WorkflowParameterBinding binding = parameterBindings[info.Name];
objArray[index] = binding.Value;
}
index++;
}
return(objArray);
}
public void TestAddRemove ()
{
WorkflowParameterBindingCollection wc = new WorkflowParameterBindingCollection (new ParallelActivity ());
WorkflowParameterBinding pb1 = new WorkflowParameterBinding ("Name1");
WorkflowParameterBinding pb2 = new WorkflowParameterBinding ("Name2");
WorkflowParameterBinding pb3 = new WorkflowParameterBinding ("Name3");
wc.Add (pb1);
wc.Add (pb2);
wc.Add (pb3);
Assert.AreEqual (3, wc.Count, "C1#1");
Assert.AreEqual (pb1, wc[0], "C1#2");
Assert.AreEqual (pb2, wc[1], "C1#3");
Assert.AreEqual (pb3, wc[2], "C1#4");
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
ParameterInfo[] formalParameters = methodBase.GetParameters();
object[] actualParameters = new object[formalParameters.Length];
int index = 0;
foreach (ParameterInfo formalParameter in formalParameters)
{
if (parameterBindings.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];
actualParameters[index] = binding.Value;
}
index++;
}
return(actualParameters);
}
public void PopulateOutputs(SendActivity activity, WorkflowParameterBindingCollection bindings, object[] outputs, object returnValue)
{
if (activity == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("activity");
}
if (outputs == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("outputs");
}
if (this.outputParameters.Count > 0 && outputs.Length > 0)
{
for (int index = 0; index < outputParameters.Count; ++index)
{
KeyValuePair <int, string> parameterInfo = outputParameters[index];
if (bindings.Contains(parameterInfo.Value))
{
bindings[parameterInfo.Value].Value = outputs[parameterInfo.Key];
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ParameterBindingMissing,
parameterInfo.Value, this.operationName, activity.Name)));
}
}
}
if (hasReturnValue)
{
if (bindings.Contains(SendActivity.ReturnValuePropertyName))
{
bindings[SendActivity.ReturnValuePropertyName].Value = returnValue;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ParameterBindingMissing,
SendActivity.ReturnValuePropertyName,
this.operationName,
activity.Name)));
}
}
}
public override object GetValue(object component)
{
WorkflowParameterBindingCollection parameters = GetParameters(component);
if (parameters != null && parameters.Contains(this.Name))
{
if (parameters[this.Name].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
return(parameters[this.Name].GetBinding(WorkflowParameterBinding.ValueProperty));
}
else
{
return(parameters[this.Name].GetValue(WorkflowParameterBinding.ValueProperty));
}
}
return(null);
}
public static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
ParameterInfo[] infoArray = methodBase.GetParameters();
object[] objArray = new object[infoArray.Length];
int ii = 0;
foreach (ParameterInfo pi in infoArray)
{
if (parameterBindings.Contains(pi.Name))
{
WorkflowParameterBinding binding = parameterBindings[pi.Name];
objArray[ii] = binding.Value;
}
ii++;
}
return(objArray);
}
internal static ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = new ValidationErrorCollection();
Activity activity = obj as Activity;
if (!(activity is CallExternalMethodActivity) && !(activity is HandleExternalEventActivity))
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(Activity).FullName }), "obj");
}
Type type = (activity is CallExternalMethodActivity) ? ((CallExternalMethodActivity)activity).InterfaceType : ((HandleExternalEventActivity)activity).InterfaceType;
if (type != null)
{
string str = (activity is CallExternalMethodActivity) ? ((CallExternalMethodActivity)activity).MethodName : ((HandleExternalEventActivity)activity).EventName;
if (string.IsNullOrEmpty(str))
{
return(validationErrors);
}
WorkflowParameterBindingCollection parameterBindings = (activity is CallExternalMethodActivity) ? ((CallExternalMethodActivity)activity).ParameterBindings : ((HandleExternalEventActivity)activity).ParameterBindings;
MethodInfo method = type.GetMethod(str);
if ((method == null) && (activity is CallExternalMethodActivity))
{
return(validationErrors);
}
bool isEvent = false;
if (method == null)
{
EventInfo eventInfo = type.GetEvent(str);
if ((eventInfo == null) || (eventInfo.GetAddMethod(true) == null))
{
return(validationErrors);
}
Type eventHandlerType = eventInfo.EventHandlerType;
if (eventHandlerType == null)
{
eventHandlerType = TypeProvider.GetEventHandlerType(eventInfo);
}
method = eventHandlerType.GetMethod("Invoke");
isEvent = true;
}
ValidateParameterBinding(manager, activity, isEvent, str, method, parameterBindings, validationErrors);
}
return(validationErrors);
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings, out ParameterModifier[] parameterModifiers)
{
ParameterInfo[] formalParameters = methodBase.GetParameters();
object[] actualParameters = new object[formalParameters.Length];
if (actualParameters.Length == 0)
{
parameterModifiers = new ParameterModifier[0];
return(actualParameters);
}
int index = 0;
BinaryFormatter formatter = null;
ParameterModifier parameterModifier = new ParameterModifier(actualParameters.Length);
foreach (ParameterInfo formalParameter in formalParameters)
{
if (formalParameter.ParameterType.IsByRef)
{
parameterModifier[index] = true;
}
else
{
parameterModifier[index] = false;
}
if (parameterBindings.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];
if (formatter == null)
{
formatter = new BinaryFormatter();
}
actualParameters[index] = CloneOutboundValue(binding.Value, formatter, formalParameter.Name);
}
index++;
}
parameterModifiers = new ParameterModifier[1] {
parameterModifier
};
return(actualParameters);
}
protected override void OnActivityChanged(ActivityChangedEventArgs e)
{
base.OnActivityChanged(e);
if ((e.Member != null) && string.Equals(e.Member.Name, "TargetWorkflow", StringComparison.Ordinal))
{
if ((e.OldValue != e.NewValue) && (base.Activity != null))
{
PropertyInfo property = base.Activity.GetType().GetProperty("ParameterBindings", BindingFlags.Public | BindingFlags.Instance);
if (property != null)
{
WorkflowParameterBindingCollection bindings = property.GetValue(base.Activity, null) as WorkflowParameterBindingCollection;
if (bindings != null)
{
bindings.Clear();
}
}
}
this.RefreshTargetWorkflowType();
}
}
public override object GetValue(object component)
{
WorkflowParameterBindingCollection parameters = GetParameterBindings(component);
string displayName = this.Name;
string propertyName = (displayName.StartsWith(parameterPrefix, StringComparison.Ordinal)) ? displayName.Substring(parameterPrefix.Length) : displayName;
if (parameters != null && parameters.Contains(propertyName))
{
if (parameters[propertyName].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
return(parameters[propertyName].GetBinding(WorkflowParameterBinding.ValueProperty));
}
else
{
return(parameters[propertyName].GetValue(WorkflowParameterBinding.ValueProperty));
}
}
return(null);
}
protected override void InitializeProperties()
{
TypedOperationInfo serviceOperationInfo = this.ServiceOperationInfo;
if (serviceOperationInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ServiceOperationInfoNotSpecified, this.Name)));
}
OperationParameterInfoCollection parameters = null;
Activity definitionRoot = base.RootActivity.GetValue(Activity.WorkflowDefinitionProperty) as Activity;
if (definitionRoot != null)
{
SendActivity definition = definitionRoot.GetActivityByName(this.QualifiedName, true) as SendActivity;
if ((definition != null) && definition.UserData.Contains(typeof(OperationParameterInfoCollection)))
{
parameters = definition.UserData[typeof(OperationParameterInfoCollection)] as OperationParameterInfoCollection;
}
}
if (parameters == null)
{
parameters = serviceOperationInfo.GetParameters(this.Site);
this.UserData[typeof(OperationParameterInfoCollection)] = parameters;
}
WorkflowParameterBindingCollection parameterBindings = this.ParameterBindings;
foreach (OperationParameterInfo parameterInfo in parameters)
{
if (!parameterBindings.Contains(parameterInfo.Name))
{
parameterBindings.Add(new WorkflowParameterBinding(parameterInfo.Name));
}
}
base.InitializeProperties();
}
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);
}
}
}
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings, out ParameterModifier[] parameterModifiers)
{
ParameterInfo[] parameters = methodBase.GetParameters();
object[] objArray = new object[parameters.Length];
if (objArray.Length == 0)
{
parameterModifiers = new ParameterModifier[0];
return(objArray);
}
int index = 0;
BinaryFormatter formatter = null;
ParameterModifier modifier = new ParameterModifier(objArray.Length);
foreach (ParameterInfo info in parameters)
{
if (info.ParameterType.IsByRef)
{
modifier[index] = true;
}
else
{
modifier[index] = false;
}
if (parameterBindings.Contains(info.Name))
{
WorkflowParameterBinding binding = parameterBindings[info.Name];
if (formatter == null)
{
formatter = new BinaryFormatter();
}
objArray[index] = CloneOutboundValue(binding.Value, formatter, info.Name);
}
index++;
}
ParameterModifier[] modifierArray = new ParameterModifier[] { modifier };
parameterModifiers = modifierArray;
return(objArray);
}
private static bool ProcessEventParameters(WorkflowParameterBindingCollection parameters, IMethodMessage message, Type interfaceType, string operation)
{
bool flag = false;
if (parameters != null)
{
MethodInfo method = interfaceType.GetEvent(operation).EventHandlerType.GetMethod("Invoke");
int index = 0;
foreach (ParameterInfo info3 in method.GetParameters())
{
if (typeof(ExternalDataEventArgs).IsAssignableFrom(info3.ParameterType) && (index == 1))
{
flag = true;
}
if (parameters.Contains(info3.Name))
{
WorkflowParameterBinding binding = parameters[info3.Name];
binding.Value = message.Args[index];
}
index++;
}
}
return flag;
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings, out ParameterModifier[] parameterModifiers)
{
ParameterInfo[] formalParameters = methodBase.GetParameters();
object[] actualParameters = new object[formalParameters.Length];
if (actualParameters.Length == 0)
{
parameterModifiers = new ParameterModifier[0];
return actualParameters;
}
int index = 0;
BinaryFormatter formatter = null;
ParameterModifier parameterModifier = new ParameterModifier(actualParameters.Length);
foreach (ParameterInfo formalParameter in formalParameters)
{
if (formalParameter.ParameterType.IsByRef)
{
parameterModifier[index] = true;
}
else
{
parameterModifier[index] = false;
}
if (parameterBindings.Contains(formalParameter.Name))
{
WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];
if (formatter == null)
formatter = new BinaryFormatter();
actualParameters[index] = CloneOutboundValue(binding.Value, formatter, formalParameter.Name);
}
index++;
}
parameterModifiers = new ParameterModifier[1] { parameterModifier };
return actualParameters;
}
internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings, out ParameterModifier[] parameterModifiers)
{
ParameterInfo[] parameters = methodBase.GetParameters();
object[] objArray = new object[parameters.Length];
if (objArray.Length == 0)
{
parameterModifiers = new ParameterModifier[0];
return objArray;
}
int index = 0;
BinaryFormatter formatter = null;
ParameterModifier modifier = new ParameterModifier(objArray.Length);
foreach (ParameterInfo info in parameters)
{
if (info.ParameterType.IsByRef)
{
modifier[index] = true;
}
else
{
modifier[index] = false;
}
if (parameterBindings.Contains(info.Name))
{
WorkflowParameterBinding binding = parameterBindings[info.Name];
if (formatter == null)
{
formatter = new BinaryFormatter();
}
objArray[index] = CloneOutboundValue(binding.Value, formatter, info.Name);
}
index++;
}
ParameterModifier[] modifierArray = new ParameterModifier[] { modifier };
parameterModifiers = modifierArray;
return objArray;
}
private static bool ProcessEventParameters(WorkflowParameterBindingCollection parameters, IMethodMessage message, Type interfaceType, string operation)
{
bool flag = false;
if (parameters != null)
{
MethodInfo method = interfaceType.GetEvent(operation).EventHandlerType.GetMethod("Invoke");
int index = 0;
foreach (ParameterInfo info3 in method.GetParameters())
{
if (typeof(ExternalDataEventArgs).IsAssignableFrom(info3.ParameterType) && (index == 1))
{
flag = true;
}
if (parameters.Contains(info3.Name))
{
WorkflowParameterBinding binding = parameters[info3.Name];
binding.Value = message.Args[index];
}
index++;
}
}
return(flag);
}
protected internal override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
TypedOperationInfo serviceOperationInfo = this.ServiceOperationInfo;
if (serviceOperationInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ServiceOperationInfoNotSpecified, this.Name)));
}
MethodInfo methodInfo = serviceOperationInfo.GetMethodInfo(executionContext);
if (methodInfo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_MethodInfoNotAvailable, this.Name)));
}
ChannelToken channelToken = this.ChannelToken;
LogicalChannel logicalChannel = ChannelToken.Register(this, channelToken, serviceOperationInfo.ContractType);
if (!logicalChannel.Initialized)
{
logicalChannel.Initialize(channelToken.EndpointName, this.CustomAddress);
}
using (ChannelManagerService.ChannelTicket leasedChannel = ChannelManagerService.Take(executionContext, this.WorkflowInstanceId, logicalChannel))
{
using (OperationContextScope scope = new OperationContextScope((IContextChannel)leasedChannel.Channel))
{
EventHandler <SendActivityEventArgs>[] invocationList = this.GetInvocationList <EventHandler <SendActivityEventArgs> >(SendActivity.BeforeSendEvent);
if (invocationList != null && invocationList.Length > 0)
{
base.RaiseGenericEvent(SendActivity.BeforeSendEvent, this, new SendActivityEventArgs(this));
}
SendOperationInfoHelper helper = this.OperationHelper;
WorkflowParameterBindingCollection bindings = this.ParameterBindings;
object[] parameters = helper.GetInputs(this, bindings);
object returnValue = null;
bool isSessionless = ChannelManagerHelpers.IsSessionlessContract(logicalChannel.ContractType);
bool hasContext = (logicalChannel.Context != null && logicalChannel.Context.Count > 0);
bool fatalException = false;
if (!isSessionless && hasContext)
{
ChannelManagerService.ApplyLogicalChannelContext(logicalChannel);
}
try
{
returnValue = this.InvokeOperation(methodInfo, leasedChannel.Channel, parameters);
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
fatalException = true;
}
throw;
}
finally
{
if (!fatalException &&
!hasContext && !isSessionless && !helper.IsOneWay)
{
ChannelManagerService.UpdateLogicalChannelContext(logicalChannel);
}
}
helper.PopulateOutputs(this, bindings, parameters, returnValue);
invocationList = this.GetInvocationList <EventHandler <SendActivityEventArgs> >(SendActivity.AfterResponseEvent);
if (invocationList != null && invocationList.Length > 0)
{
base.RaiseGenericEvent(SendActivity.AfterResponseEvent, this, new SendActivityEventArgs(this));
}
}
}
return(ActivityExecutionStatus.Closed);
}
internal static void InitializeParameters(MethodInfo methodBase, WorkflowParameterBindingCollection parameterBindings)
{
foreach (ParameterInfo info in methodBase.GetParameters())
{
if (!parameterBindings.Contains(info.Name))
{
parameterBindings.Add(new WorkflowParameterBinding(info.Name));
}
}
if ((methodBase.ReturnType != typeof(void)) && !parameterBindings.Contains("(ReturnValue)"))
{
parameterBindings.Add(new WorkflowParameterBinding("(ReturnValue)"));
}
}
internal static void SaveOutRefParameters(object[] actualParameters, MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
int index = 0;
BinaryFormatter formatter = null;
foreach (ParameterInfo info in methodBase.GetParameters())
{
if (parameterBindings.Contains(info.Name) && (info.ParameterType.IsByRef || (info.IsIn && info.IsOut)))
{
WorkflowParameterBinding binding = parameterBindings[info.Name];
if (formatter == null)
{
formatter = new BinaryFormatter();
}
binding.Value = CloneOutboundValue(actualParameters[index], formatter, info.Name);
}
index++;
}
}
private static void ValidateParameterBinding(ValidationManager manager, Activity activity, bool isEvent, string operation, MethodInfo mInfo, WorkflowParameterBindingCollection parameterBindings, ValidationErrorCollection validationErrors)
{
Hashtable hashtable = new Hashtable();
ParameterInfo[] parameters = mInfo.GetParameters();
bool flag = false;
foreach (ParameterInfo info in parameters)
{
if (TypeProvider.IsAssignable(typeof(ExternalDataEventArgs), info.ParameterType))
{
if (info.Position == 1)
{
flag = true;
}
ValidateParameterSerializabiltiy(validationErrors, info.ParameterType);
}
hashtable.Add(info.Name, info);
}
if (isEvent && (!flag || (parameters.Length != 2)))
{
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString("Error_InvalidEventArgsSignature", new object[] { operation }), new object[0]), 0x120, false, "EventName"));
}
if (mInfo.ReturnType != typeof(void))
{
hashtable.Add("(ReturnValue)", mInfo.ReturnParameter);
}
foreach (WorkflowParameterBinding binding in parameterBindings)
{
string parameterName = binding.ParameterName;
if (!hashtable.ContainsKey(parameterName))
{
if (isEvent)
{
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString("Error_InvalidEventPropertyName", new object[] { parameterName }), new object[0]), 0x120, false, "ParameterBindings"));
}
else
{
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString("Error_InvalidMethodPropertyName", new object[] { parameterName }), new object[0]), 0x120, false, "ParameterBindings"));
}
}
else
{
object obj2 = null;
if (binding.IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
obj2 = binding.GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
obj2 = binding.GetValue(WorkflowParameterBinding.ValueProperty);
}
if (obj2 != null)
{
ParameterInfo info2 = hashtable[parameterName] as ParameterInfo;
if (info2 != null)
{
AccessTypes read = AccessTypes.Read;
if (info2.IsOut || info2.IsRetval)
{
read = AccessTypes.Write;
}
else if (info2.ParameterType.IsByRef)
{
read |= AccessTypes.Write;
}
ValidationErrorCollection errors = System.Workflow.Activities.Common.ValidationHelpers.ValidateProperty(manager, activity, obj2, new PropertyValidationContext(binding, null, parameterName), new BindValidationContext(info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType, read));
validationErrors.AddRange(errors);
}
}
}
}
}
public CallExternalMethodActivity ()
{
ParameterBindings = new WorkflowParameterBindingCollection (this);
}
internal static void SaveOutRefParameters(object[] actualParameters, MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
int index = 0;
BinaryFormatter formatter = null;
foreach (ParameterInfo formalParameter in methodBase.GetParameters())
{
if (parameterBindings.Contains(formalParameter.Name))
{
if (formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut))
{
WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];
if (formatter == null)
formatter = new BinaryFormatter();
binding.Value = CloneOutboundValue(actualParameters[index], formatter, formalParameter.Name);
}
}
index++;
}
}
public void TestConstructorNullException ()
{
WorkflowParameterBindingCollection wc = new WorkflowParameterBindingCollection (new ParallelActivity ());
WorkflowParameterBinding pb1 = new WorkflowParameterBinding ();
wc.Add (pb1);
}
public static void SaveOutRefParameters(object[] actualParameters, MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
{
int ii = 0;
BinaryFormatter bf = null;
foreach (ParameterInfo pi in methodBase.GetParameters())
{
if (parameterBindings.Contains(pi.Name) && (pi.ParameterType.IsByRef || (pi.IsIn && pi.IsOut)))
{
WorkflowParameterBinding binding = parameterBindings[pi.Name];
if (bf == null)
{
bf = new BinaryFormatter();
}
binding.Value = CloneOutboundValue(actualParameters[ii], bf, pi.Name);
}
ii++;
}
}
public void PopulateOutputs(SendActivity activity, WorkflowParameterBindingCollection bindings, object[] outputs, object returnValue)
{
if (activity == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("activity");
}
if (outputs == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("outputs");
}
if (this.outputParameters.Count > 0 && outputs.Length > 0)
{
for (int index = 0; index < outputParameters.Count; ++index)
{
KeyValuePair<int, string> parameterInfo = outputParameters[index];
if (bindings.Contains(parameterInfo.Value))
{
bindings[parameterInfo.Value].Value = outputs[parameterInfo.Key];
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ParameterBindingMissing,
parameterInfo.Value, this.operationName, activity.Name)));
}
}
}
if (hasReturnValue)
{
if (bindings.Contains(SendActivity.ReturnValuePropertyName))
{
bindings[SendActivity.ReturnValuePropertyName].Value = returnValue;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ParameterBindingMissing,
SendActivity.ReturnValuePropertyName,
this.operationName,
activity.Name)));
}
}
}
public override void SetValue(object component, object value)
{
// the logic for notifications is borrowed from ReflectPropertyDescritpor
if (component == null)
{
return;
}
IServiceProvider serviceProvider = GetSite(component);
ComponentChangeDispatcher componentChange = (serviceProvider != null) ? new ComponentChangeDispatcher(serviceProvider, component, this) : null;
try
{
WorkflowParameterBindingCollection parameters = GetParameterBindings(component);
if (parameters != null)
{
string propertyName = String.Empty;
if (this.Name.StartsWith(parameterPrefix, StringComparison.Ordinal))
{
propertyName = this.Name.Substring(parameterPrefix.Length);
}
else
{
propertyName = this.Name;
}
WorkflowParameterBinding binding = null;
if (parameters.Contains(propertyName))
{
binding = parameters[propertyName];
}
else
{
binding = new WorkflowParameterBinding(propertyName);
parameters.Add(binding);
}
if (value is ActivityBind)
{
binding.SetBinding(WorkflowParameterBinding.ValueProperty, value as ActivityBind);
}
else
{
binding.SetValue(WorkflowParameterBinding.ValueProperty, value);
}
OnValueChanged(component, EventArgs.Empty);
}
}
catch (Exception t)
{
// If there was a problem setting the controls property then we get:
// ArgumentException (from properties set method)
// ==> Becomes inner exception of TargetInvocationException
// ==> caught here
// Propagate the original exception up
if (t is TargetInvocationException && t.InnerException != null)
{
throw t.InnerException;
}
else
{
throw t;
}
}
finally
{
// Now notify the change service that the change was successful.
if (componentChange != null)
{
componentChange.Dispose();
}
}
}
public override void SetValue(object component, object value)
{
if (component != null)
{
ISite site = GetSite(component);
IComponentChangeService changeService = null;
if (site != null)
{
changeService = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
}
// Raise the OnComponentChanging event
changeService.OnComponentChanging(component, this);
// Save the old value
object oldValue = GetValue(component);
try
{
WorkflowParameterBindingCollection parameters = GetParameters(component);
if (parameters != null)
{
if (value == null)
{
// Remove the binding from the ParameterBindings collection
parameters.Remove(this.Name);
}
else
{
// Add the binding to the ParameterBindings collection
WorkflowParameterBinding binding = null;
if (parameters.Contains(this.Name))
{
binding = parameters[this.Name];
}
else
{
binding = new WorkflowParameterBinding(this.Name);
parameters.Add(binding);
}
// Set the binding value on the ParameterBindings collection correspondent binding item
if (value is ActivityBind)
{
binding.SetBinding(WorkflowParameterBinding.ValueProperty, value as ActivityBind);
}
else
{
binding.SetValue(WorkflowParameterBinding.ValueProperty, value);
}
}
}
// Raise the OnValueChanged event
OnValueChanged(component, EventArgs.Empty);
}
catch (Exception)
{
value = oldValue;
throw;
}
finally
{
if (changeService != null)
{
// Raise the OnComponentChanged event
changeService.OnComponentChanged(component, this, oldValue, value);
}
}
}
}
public object[] GetInputs(SendActivity activity, WorkflowParameterBindingCollection bindings)
{
if (activity == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("activity");
}
object[] inputs = new object[this.parameterCount];
if (inputParameters.Count > 0)
{
for (int index = 0; index < inputParameters.Count; index++)
{
KeyValuePair<int, string> parameterInfo = inputParameters[index];
if (bindings.Contains(parameterInfo.Value))
{
inputs[parameterInfo.Key] = bindings[parameterInfo.Value].Value;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR2.GetString(SR2.Error_ParameterBindingMissing,
parameterInfo.Value,
this.operationName,
activity.Name)));
}
}
}
return inputs;
}
private static void ValidateParameterBinding(ValidationManager manager, Activity activity, bool isEvent, string operation, MethodInfo mInfo, WorkflowParameterBindingCollection parameterBindings, ValidationErrorCollection validationErrors)
{
Hashtable parameterCollection = new Hashtable();
ParameterInfo[] parameters = mInfo.GetParameters();
bool canBeIntercepted = false;
foreach (ParameterInfo parameter in parameters)
{
if (TypeProvider.IsAssignable(typeof(ExternalDataEventArgs), parameter.ParameterType))
{
if (parameter.Position == 1)
canBeIntercepted = true;
ValidateParameterSerializabiltiy(validationErrors, parameter.ParameterType);
}
parameterCollection.Add(parameter.Name, parameter);
}
if (isEvent && (!canBeIntercepted || parameters.Length != 2))
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Error_InvalidEventArgsSignature, operation)), ErrorNumbers.Error_FieldNotExists, false, "EventName"));
if (mInfo.ReturnType != typeof(void))
parameterCollection.Add("(ReturnValue)", mInfo.ReturnParameter);
foreach (WorkflowParameterBinding parameterBinding in parameterBindings)
{
string paramName = parameterBinding.ParameterName;
if (!parameterCollection.ContainsKey(paramName))
{
if (isEvent)
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Error_InvalidEventPropertyName, paramName)), ErrorNumbers.Error_FieldNotExists, false, "ParameterBindings"));
else
validationErrors.Add(new ValidationError(string.Format(CultureInfo.CurrentCulture, SR.GetString(SR.Error_InvalidMethodPropertyName, paramName)), ErrorNumbers.Error_FieldNotExists, false, "ParameterBindings"));
continue;
}
object paramValue = null;
if (parameterBinding.IsBindingSet(WorkflowParameterBinding.ValueProperty))
paramValue = parameterBinding.GetBinding(WorkflowParameterBinding.ValueProperty);
else
paramValue = parameterBinding.GetValue(WorkflowParameterBinding.ValueProperty);
if (paramValue == null)
continue;
ParameterInfo paramInfo = parameterCollection[paramName] as ParameterInfo;
if (paramInfo != null)
{
AccessTypes access = AccessTypes.Read;
if (paramInfo.IsOut || paramInfo.IsRetval)
access = AccessTypes.Write;
else if (paramInfo.ParameterType.IsByRef)
access |= AccessTypes.Write;
ValidationErrorCollection variableErrors = ValidationHelpers.ValidateProperty(manager, activity, paramValue,
new PropertyValidationContext(parameterBinding, null, paramName),
new BindValidationContext(paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType, access));
validationErrors.AddRange(variableErrors);
}
}
}
