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 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); } } }