internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
{
return;
}
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
if (this.InputActivityName != null && !String.IsNullOrEmpty(this.InputActivityName.Trim()))
{
WebServiceInputActivity webServiceReceive = Helpers.ParseActivity(Helpers.GetRootActivity(this), this.InputActivityName) as WebServiceInputActivity;
if (webServiceReceive != null)
{
Type type = null;
if (webServiceReceive.InterfaceType != null)
{
type = typeProvider.GetType(webServiceReceive.InterfaceType.AssemblyQualifiedName);
}
if (type != null)
{
MethodInfo method = Helpers.GetInterfaceMethod(type, webServiceReceive.MethodName);
if (method != null && WebServiceActivityHelpers.ValidateParameterTypes(method).Count == 0)
{
List <ParameterInfo> inputParameters, outParameters;
WebServiceActivityHelpers.GetParameterInfo(method, out inputParameters, out outParameters);
foreach (ParameterInfo paramInfo in outParameters)
{
PropertyDescriptor prop = null;
if (paramInfo.Position == -1)
{
prop = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceOutputActivity), paramInfo, false, DesignOnlyAttribute.Yes);
}
else
{
prop = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceOutputActivity), paramInfo, true, DesignOnlyAttribute.Yes);
}
if (prop != null)
{
properties[prop.Name] = prop;
}
}
}
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
{
return;
}
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type type = this.InterfaceType;
if (type == null)
{
return;
}
if (this.GetType() != typeof(HandleExternalEventActivity))
{
return; // if custom activity do not add parameter binding
}
EventInfo eventInfo = type.GetEvent(this.EventName);
if (eventInfo != null)
{
Type delegateType = TypeProvider.GetEventHandlerType(eventInfo);
if (delegateType != null)
{
MethodInfo method = delegateType.GetMethod("Invoke");
ArrayList paramInfo = new ArrayList();
if (method != null)
{
paramInfo.AddRange(method.GetParameters());
if (!(method.ReturnType == typeof(void)))
{
paramInfo.Add(method.ReturnParameter);
}
}
foreach (ParameterInfo param in paramInfo)
{
PropertyDescriptor prop = new ParameterInfoBasedPropertyDescriptor(typeof(HandleExternalEventActivity), param, true, DesignOnlyAttribute.Yes);
properties[prop.Name] = prop;
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (this.Site != null)
{
ITypeProvider service = (ITypeProvider)this.Site.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
if ((this.InputActivityName != null) && !string.IsNullOrEmpty(this.InputActivityName.Trim()))
{
WebServiceInputActivity activity = Helpers.ParseActivity(Helpers.GetRootActivity(this), this.InputActivityName) as WebServiceInputActivity;
if (activity != null)
{
Type interfaceType = null;
if (activity.InterfaceType != null)
{
interfaceType = service.GetType(activity.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType != null)
{
MethodInfo interfaceMethod = Helpers.GetInterfaceMethod(interfaceType, activity.MethodName);
if ((interfaceMethod != null) && (WebServiceActivityHelpers.ValidateParameterTypes(interfaceMethod).Count == 0))
{
List <ParameterInfo> list;
List <ParameterInfo> list2;
WebServiceActivityHelpers.GetParameterInfo(interfaceMethod, out list, out list2);
foreach (ParameterInfo info2 in list2)
{
PropertyDescriptor descriptor = null;
if (info2.Position == -1)
{
descriptor = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceOutputActivity), info2, false, new Attribute[] { DesignOnlyAttribute.Yes });
}
else
{
descriptor = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceOutputActivity), info2, true, new Attribute[] { DesignOnlyAttribute.Yes });
}
if (descriptor != null)
{
properties[descriptor.Name] = descriptor;
}
}
}
}
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
{
return;
}
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type type = this.ProxyClass;
if (type != null)
{
MethodInfo method = type.GetMethod(this.MethodName);
if (method != null)
{
ArrayList paramInfos = new ArrayList(method.GetParameters());
if (!(method.ReturnType == typeof(void)))
{
paramInfos.Add(method.ReturnParameter);
}
foreach (ParameterInfo paramInfo in paramInfos)
{
if (paramInfo.ParameterType != null)
{
PropertyDescriptor prop = null;
if (paramInfo.Position == -1)
{
prop = new ParameterInfoBasedPropertyDescriptor(typeof(InvokeWebServiceActivity), paramInfo, false, DesignOnlyAttribute.Yes);
}
else
{
prop = new ParameterInfoBasedPropertyDescriptor(typeof(InvokeWebServiceActivity), paramInfo, InvokeWebServiceActivity.ReservedParameterNames.Contains(paramInfo.Name), DesignOnlyAttribute.Yes);
}
// return this parameter
properties[prop.Name] = prop;
}
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
{
return;
}
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
if (this.GetType() != typeof(CallExternalMethodActivity))
{
return; // if custom activity do not add parameter binding
}
Type type = this.InterfaceType;
if (type == null)
{
return;
}
MethodInfo method = type.GetMethod(this.MethodName);
if (method != null)
{
ArrayList paramInfo = new ArrayList(method.GetParameters());
if (!(method.ReturnType == typeof(void)))
{
paramInfo.Add(method.ReturnParameter);
}
foreach (ParameterInfo param in paramInfo)
{
if (param.ParameterType != null)
{
PropertyDescriptor prop = new ParameterInfoBasedPropertyDescriptor(typeof(CallExternalMethodActivity), param, true, DesignOnlyAttribute.Yes);
properties[prop.Name] = prop;
}
}
}
}
Type IDynamicPropertyTypeProvider.GetPropertyType(IServiceProvider serviceProvider, string propertyName)
{
if (propertyName == null)
{
throw new ArgumentNullException("propertyName");
}
Dictionary <string, object> properties = new Dictionary <string, object>();
this.GetParameterPropertyDescriptors(properties);
if (properties.ContainsKey(propertyName))
{
ParameterInfoBasedPropertyDescriptor descriptor = properties[propertyName] as ParameterInfoBasedPropertyDescriptor;
if (descriptor != null)
{
return(descriptor.ParameterType);
}
}
return(null);
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (this.Site != null)
{
if (((ITypeProvider)this.Site.GetService(typeof(ITypeProvider))) == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
Type proxyClass = this.ProxyClass;
if (proxyClass != null)
{
MethodInfo method = proxyClass.GetMethod(this.MethodName);
if (method != null)
{
ArrayList list = new ArrayList(method.GetParameters());
if (!(method.ReturnType == typeof(void)))
{
list.Add(method.ReturnParameter);
}
foreach (ParameterInfo info2 in list)
{
if (info2.ParameterType != null)
{
PropertyDescriptor descriptor = null;
if (info2.Position == -1)
{
descriptor = new ParameterInfoBasedPropertyDescriptor(typeof(InvokeWebServiceActivity), info2, false, new Attribute[] { DesignOnlyAttribute.Yes });
}
else
{
descriptor = new ParameterInfoBasedPropertyDescriptor(typeof(InvokeWebServiceActivity), info2, ReservedParameterNames.Contains(info2.Name), new Attribute[] { DesignOnlyAttribute.Yes });
}
properties[descriptor.Name] = descriptor;
}
}
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (properties == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("properties");
}
if (((IComponent)this).Site == null)
{
return;
}
TypedOperationInfo serviceOperationInfo = this.ServiceOperationInfo;
if (serviceOperationInfo != null)
{
MethodInfo methodInfo = serviceOperationInfo.GetMethodInfo(((IComponent)this).Site);
if (methodInfo != null)
{
ArrayList paramInfo = new ArrayList(methodInfo.GetParameters());
if (!(methodInfo.ReturnType == typeof(void)))
{
paramInfo.Add(methodInfo.ReturnParameter);
}
foreach (ParameterInfo param in paramInfo)
{
if (param.ParameterType != null)
{
PropertyDescriptor prop =
new ParameterInfoBasedPropertyDescriptor(typeof(ReceiveActivity),
param, true, DesignOnlyAttribute.Yes);
properties[prop.Name] = prop;
}
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
{
return;
}
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type type = null;
if (this.InterfaceType != null)
{
type = typeProvider.GetType(this.InterfaceType.AssemblyQualifiedName);
}
if (type != null && type.IsInterface)
{
MethodInfo method = Helpers.GetInterfaceMethod(type, this.MethodName);
if (method != null && WebServiceActivityHelpers.ValidateParameterTypes(method).Count == 0)
{
List <ParameterInfo> inputParameters, outParameters;
WebServiceActivityHelpers.GetParameterInfo(method, out inputParameters, out outParameters);
foreach (ParameterInfo paramInfo in inputParameters)
{
PropertyDescriptor prop = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceInputActivity), paramInfo, true, DesignOnlyAttribute.Yes);
properties[prop.Name] = prop;
}
}
}
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
WebServiceInputActivity activity = obj as WebServiceInputActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(WebServiceInputActivity).FullName }), "obj");
}
if (!Helpers.IsActivityLocked(activity))
{
List <ParameterInfo> list;
List <ParameterInfo> list2;
if (activity.IsActivating)
{
if (WebServiceActivityHelpers.GetPreceedingActivities(activity).GetEnumerator().MoveNext())
{
ValidationError item = new ValidationError(SR.GetString("Error_ActivationActivityNotFirst"), 0x568)
{
PropertyName = "IsActivating"
};
errors.Add(item);
return(errors);
}
if (WebServiceActivityHelpers.IsInsideLoop(activity, null))
{
ValidationError error2 = new ValidationError(SR.GetString("Error_ActivationActivityInsideLoop"), 0x579)
{
PropertyName = "IsActivating"
};
errors.Add(error2);
return(errors);
}
}
else if (!WebServiceActivityHelpers.GetPreceedingActivities(activity, true).GetEnumerator().MoveNext())
{
ValidationError error3 = new ValidationError(SR.GetString("Error_WebServiceReceiveNotMarkedActivate"), 0x569)
{
PropertyName = "IsActivating"
};
errors.Add(error3);
return(errors);
}
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
Type interfaceType = null;
if (activity.InterfaceType != null)
{
interfaceType = service.GetType(activity.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType == null)
{
ValidationError error4 = new ValidationError(SR.GetString("Error_TypePropertyInvalid", new object[] { "InterfaceType" }), 0x116)
{
PropertyName = "InterfaceType"
};
errors.Add(error4);
return(errors);
}
if (!interfaceType.IsInterface)
{
ValidationError error5 = new ValidationError(SR.GetString("Error_InterfaceTypeNotInterface", new object[] { "InterfaceType" }), 0x570)
{
PropertyName = "InterfaceType"
};
errors.Add(error5);
return(errors);
}
if (string.IsNullOrEmpty(activity.MethodName))
{
errors.Add(ValidationError.GetNotSetValidationError("MethodName"));
return(errors);
}
MethodInfo interfaceMethod = Helpers.GetInterfaceMethod(interfaceType, activity.MethodName);
if (interfaceMethod == null)
{
ValidationError error6 = new ValidationError(SR.GetString("Error_MethodNotExists", new object[] { "MethodName", activity.MethodName }), 0x137)
{
PropertyName = "MethodName"
};
errors.Add(error6);
return(errors);
}
ValidationErrorCollection errors2 = WebServiceActivityHelpers.ValidateParameterTypes(interfaceMethod);
if (errors2.Count > 0)
{
foreach (ValidationError error7 in errors2)
{
error7.PropertyName = "MethodName";
}
errors.AddRange(errors2);
return(errors);
}
WebServiceActivityHelpers.GetParameterInfo(interfaceMethod, out list, out list2);
foreach (ParameterInfo info2 in list)
{
string name = info2.Name;
string parameterPropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity.GetType(), name);
Type type2 = info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType;
object binding = null;
if (activity.ParameterBindings.Contains(name))
{
if (activity.ParameterBindings[name].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
binding = activity.ParameterBindings[name].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
binding = activity.ParameterBindings[name].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!type2.IsPublic || !type2.IsSerializable)
{
ValidationError error8 = new ValidationError(SR.GetString("Error_TypeNotPublicSerializable", new object[] { name, type2.FullName }), 0x567)
{
PropertyName = parameterPropertyName
};
errors.Add(error8);
}
else if (!activity.ParameterBindings.Contains(name) || (binding == null))
{
ValidationError notSetValidationError = ValidationError.GetNotSetValidationError(name);
notSetValidationError.PropertyName = parameterPropertyName;
errors.Add(notSetValidationError);
}
else
{
AccessTypes read = AccessTypes.Read;
if (info2.ParameterType.IsByRef)
{
read |= AccessTypes.Write;
}
ValidationErrorCollection errors3 = System.Workflow.Activities.Common.ValidationHelpers.ValidateProperty(manager, activity, binding, new PropertyValidationContext(activity.ParameterBindings[name], null, name), new BindValidationContext(info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType, read));
foreach (ValidationError error10 in errors3)
{
error10.PropertyName = parameterPropertyName;
}
errors.AddRange(errors3);
}
}
if (activity.ParameterBindings.Count > list.Count)
{
errors.Add(new ValidationError(SR.GetString("Warning_AdditionalBindingsFound"), 0x630, true));
}
bool flag = false;
foreach (Activity activity2 in WebServiceActivityHelpers.GetSucceedingActivities(activity))
{
if (((activity2 is WebServiceOutputActivity) && (((WebServiceOutputActivity)activity2).InputActivityName == activity.Name)) || ((activity2 is WebServiceFaultActivity) && (((WebServiceFaultActivity)activity2).InputActivityName == activity.Name)))
{
flag = true;
break;
}
}
if (((list2.Count > 0) || (interfaceMethod.ReturnType != typeof(void))) && !flag)
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceResponseNotFound"), 0x55d));
}
}
return(errors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
WebServiceInputActivity webServiceReceive = obj as WebServiceInputActivity;
if (webServiceReceive == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(WebServiceInputActivity).FullName), "obj");
}
if (Helpers.IsActivityLocked(webServiceReceive))
{
return(validationErrors);
}
if (webServiceReceive.IsActivating)
{
if (WebServiceActivityHelpers.GetPreceedingActivities(webServiceReceive).GetEnumerator().MoveNext() == true)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_ActivationActivityNotFirst), ErrorNumbers.Error_ActivationActivityNotFirst);
error.PropertyName = "IsActivating";
validationErrors.Add(error);
return(validationErrors);
}
if (WebServiceActivityHelpers.IsInsideLoop(webServiceReceive, null))
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_ActivationActivityInsideLoop), ErrorNumbers.Error_ActivationActivityInsideLoop);
error.PropertyName = "IsActivating";
validationErrors.Add(error);
return(validationErrors);
}
}
else
{
if (WebServiceActivityHelpers.GetPreceedingActivities(webServiceReceive, true).GetEnumerator().MoveNext() == false)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotMarkedActivate), ErrorNumbers.Error_WebServiceReceiveNotMarkedActivate);
error.PropertyName = "IsActivating";
validationErrors.Add(error);
return(validationErrors);
}
}
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type interfaceType = null;
if (webServiceReceive.InterfaceType != null)
{
interfaceType = typeProvider.GetType(webServiceReceive.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "InterfaceType"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "InterfaceType";
validationErrors.Add(error);
}
else if (!interfaceType.IsInterface)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_InterfaceTypeNotInterface, "InterfaceType"), ErrorNumbers.Error_InterfaceTypeNotInterface);
error.PropertyName = "InterfaceType";
validationErrors.Add(error);
}
else
{
// Validate method
if (String.IsNullOrEmpty(webServiceReceive.MethodName))
{
validationErrors.Add(ValidationError.GetNotSetValidationError("MethodName"));
}
else
{
MethodInfo methodInfo = Helpers.GetInterfaceMethod(interfaceType, webServiceReceive.MethodName);
if (methodInfo == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_MethodNotExists, "MethodName", webServiceReceive.MethodName), ErrorNumbers.Error_MethodNotExists);
error.PropertyName = "MethodName";
validationErrors.Add(error);
}
else
{
ValidationErrorCollection parameterTypeErrors = WebServiceActivityHelpers.ValidateParameterTypes(methodInfo);
if (parameterTypeErrors.Count > 0)
{
foreach (ValidationError parameterTypeError in parameterTypeErrors)
{
parameterTypeError.PropertyName = "MethodName";
}
validationErrors.AddRange(parameterTypeErrors);
}
else
{
List <ParameterInfo> inputParameters, outParameters;
WebServiceActivityHelpers.GetParameterInfo(methodInfo, out inputParameters, out outParameters);
// Check to see if all input parameters have a valid binding.
foreach (ParameterInfo paramInfo in inputParameters)
{
string paramName = paramInfo.Name;
string parameterPropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(webServiceReceive.GetType(), paramName);
Type paramType = paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType;
object paramValue = null;
if (webServiceReceive.ParameterBindings.Contains(paramName))
{
if (webServiceReceive.ParameterBindings[paramName].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
paramValue = webServiceReceive.ParameterBindings[paramName].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
paramValue = webServiceReceive.ParameterBindings[paramName].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!paramType.IsPublic || !paramType.IsSerializable)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_TypeNotPublicSerializable, paramName, paramType.FullName), ErrorNumbers.Error_TypeNotPublicSerializable);
validationError.PropertyName = parameterPropertyName;
validationErrors.Add(validationError);
}
else if (!webServiceReceive.ParameterBindings.Contains(paramName) || paramValue == null)
{
ValidationError validationError = ValidationError.GetNotSetValidationError(paramName);
validationError.PropertyName = parameterPropertyName;
validationErrors.Add(validationError);
}
else
{
AccessTypes access = AccessTypes.Read;
if (paramInfo.ParameterType.IsByRef)
{
access |= AccessTypes.Write;
}
ValidationErrorCollection variableErrors = ValidationHelpers.ValidateProperty(manager, webServiceReceive, paramValue,
new PropertyValidationContext(webServiceReceive.ParameterBindings[paramName], null, paramName), new BindValidationContext(paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType, access));
foreach (ValidationError validationError in variableErrors)
{
validationError.PropertyName = parameterPropertyName;
}
validationErrors.AddRange(variableErrors);
}
}
if (webServiceReceive.ParameterBindings.Count > inputParameters.Count)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_AdditionalBindingsFound), ErrorNumbers.Warning_AdditionalBindingsFound, true));
}
bool foundMatchingResponse = false;
foreach (Activity succeedingActivity in WebServiceActivityHelpers.GetSucceedingActivities(webServiceReceive))
{
if ((succeedingActivity is WebServiceOutputActivity && ((WebServiceOutputActivity)succeedingActivity).InputActivityName == webServiceReceive.Name) ||
(succeedingActivity is WebServiceFaultActivity && ((WebServiceFaultActivity)succeedingActivity).InputActivityName == webServiceReceive.Name))
{
foundMatchingResponse = true;
break;
}
}
// If the method has out parameters or is the method has a return value,
// check to see if there are any corresponding WebServiceResponse activities.
if ((outParameters.Count > 0 || methodInfo.ReturnType != typeof(void)) && !foundMatchingResponse)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceResponseNotFound), ErrorNumbers.Error_WebServiceResponseNotFound));
}
}
}
}
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
InvokeWebServiceActivity activity = obj as InvokeWebServiceActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(InvokeWebServiceActivity).FullName }), "obj");
}
if (activity.ProxyClass == null)
{
ValidationError item = new ValidationError(SR.GetString("Error_TypePropertyInvalid", new object[] { "ProxyClass" }), 0x116)
{
PropertyName = "ProxyClass"
};
errors.Add(item);
return(errors);
}
if (((ITypeProvider)manager.GetService(typeof(ITypeProvider))) == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
Type proxyClass = activity.ProxyClass;
if ((activity.MethodName == null) || (activity.MethodName.Length == 0))
{
errors.Add(ValidationError.GetNotSetValidationError("MethodName"));
return(errors);
}
MethodInfo method = proxyClass.GetMethod(activity.MethodName);
if (method == null)
{
ValidationError error2 = new ValidationError(SR.GetString("Error_MethodNotExists", new object[] { "MethodName", activity.MethodName }), 0x137)
{
PropertyName = "MethodName"
};
errors.Add(error2);
return(errors);
}
ArrayList list = new ArrayList(method.GetParameters());
if (method.ReturnType != typeof(void))
{
list.Add(method.ReturnParameter);
}
foreach (ParameterInfo info2 in list)
{
string name = info2.Name;
if (info2.Position == -1)
{
name = "(ReturnValue)";
}
object binding = null;
if (activity.ParameterBindings.Contains(name))
{
if (activity.ParameterBindings[name].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
binding = activity.ParameterBindings[name].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
binding = activity.ParameterBindings[name].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!activity.ParameterBindings.Contains(name) || (binding == null))
{
ValidationError notSetValidationError = ValidationError.GetNotSetValidationError(name);
if (InvokeWebServiceActivity.ReservedParameterNames.Contains(name))
{
notSetValidationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity.GetType(), name);
}
notSetValidationError.PropertyName = name;
errors.Add(notSetValidationError);
}
else
{
AccessTypes read = AccessTypes.Read;
if (info2.IsOut || info2.IsRetval)
{
read = AccessTypes.Write;
}
else if (info2.ParameterType.IsByRef)
{
read |= AccessTypes.Write;
}
ValidationErrorCollection errors2 = System.Workflow.Activities.Common.ValidationHelpers.ValidateProperty(manager, activity, binding, new PropertyValidationContext(activity.ParameterBindings[name], null, name), new BindValidationContext(info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType, read));
if (InvokeWebServiceActivity.ReservedParameterNames.Contains(name))
{
foreach (ValidationError error4 in errors2)
{
error4.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity.GetType(), name);
}
}
errors.AddRange(errors2);
}
}
if (activity.ParameterBindings.Count > list.Count)
{
errors.Add(new ValidationError(SR.GetString("Warning_AdditionalBindingsFound"), 0x630, true));
}
return(errors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
WebServiceOutputActivity activity = obj as WebServiceOutputActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(WebServiceOutputActivity).FullName }), "obj");
}
if (!Helpers.IsActivityLocked(activity))
{
List <ParameterInfo> list;
List <ParameterInfo> list2;
WebServiceInputActivity activity2 = null;
if (string.IsNullOrEmpty(activity.InputActivityName))
{
errors.Add(ValidationError.GetNotSetValidationError("InputActivityName"));
return(errors);
}
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
bool flag = false;
foreach (Activity activity3 in WebServiceActivityHelpers.GetPreceedingActivities(activity))
{
if (((activity3 is WebServiceOutputActivity) && (string.Compare(((WebServiceOutputActivity)activity3).InputActivityName, activity.InputActivityName, StringComparison.Ordinal) == 0)) || ((activity3 is WebServiceFaultActivity) && (string.Compare(((WebServiceFaultActivity)activity3).InputActivityName, activity.InputActivityName, StringComparison.Ordinal) == 0)))
{
if (activity3 is WebServiceOutputActivity)
{
errors.Add(new ValidationError(SR.GetString("Error_DuplicateWebServiceResponseFound", new object[] { activity3.QualifiedName, activity.InputActivityName }), 0x56a));
return(errors);
}
errors.Add(new ValidationError(SR.GetString("Error_DuplicateWebServiceFaultFound", new object[] { activity3.QualifiedName, activity.InputActivityName }), 0x574));
return(errors);
}
}
foreach (Activity activity4 in WebServiceActivityHelpers.GetPreceedingActivities(activity))
{
if (string.Compare(activity4.QualifiedName, activity.InputActivityName, StringComparison.Ordinal) == 0)
{
if (activity4 is WebServiceInputActivity)
{
activity2 = activity4 as WebServiceInputActivity;
flag = true;
break;
}
flag = false;
errors.Add(new ValidationError(SR.GetString("Error_WebServiceReceiveNotValid", new object[] { activity.InputActivityName }), 0x564));
return(errors);
}
}
if (!flag)
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceReceiveNotFound", new object[] { activity.InputActivityName }), 0x55e));
return(errors);
}
Type interfaceType = null;
if (activity2.InterfaceType != null)
{
interfaceType = service.GetType(activity2.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType == null)
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceReceiveNotConfigured", new object[] { activity2.Name }), 0x566));
return(errors);
}
if (string.IsNullOrEmpty(activity2.MethodName))
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceReceiveNotConfigured", new object[] { activity2.Name }), 0x566));
return(errors);
}
MethodInfo interfaceMethod = Helpers.GetInterfaceMethod(interfaceType, activity2.MethodName);
if (interfaceMethod == null)
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceReceiveNotConfigured", new object[] { activity2.Name }), 0x566));
return(errors);
}
ValidationErrorCollection errors2 = WebServiceActivityHelpers.ValidateParameterTypes(interfaceMethod);
if (errors2.Count > 0)
{
foreach (ValidationError error in errors2)
{
error.PropertyName = "InputActivityName";
}
errors.AddRange(errors2);
return(errors);
}
WebServiceActivityHelpers.GetParameterInfo(interfaceMethod, out list, out list2);
if (list2.Count == 0)
{
errors.Add(new ValidationError(SR.GetString("Error_WebServiceResponseNotNeeded"), 0x565));
return(errors);
}
foreach (ParameterInfo info2 in list2)
{
string name = info2.Name;
Type type2 = info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType;
if (info2.Position == -1)
{
name = "(ReturnValue)";
}
object binding = null;
if (activity.ParameterBindings.Contains(name))
{
if (activity.ParameterBindings[name].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
binding = activity.ParameterBindings[name].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
binding = activity.ParameterBindings[name].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!type2.IsPublic || !type2.IsSerializable)
{
ValidationError item = new ValidationError(SR.GetString("Error_TypeNotPublicSerializable", new object[] { name, type2.FullName }), 0x567)
{
PropertyName = (string.Compare(name, "(ReturnValue)", StringComparison.Ordinal) == 0) ? name : ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity2.GetType(), name)
};
errors.Add(item);
}
else if (!activity.ParameterBindings.Contains(name) || (binding == null))
{
ValidationError notSetValidationError = ValidationError.GetNotSetValidationError(name);
notSetValidationError.PropertyName = (string.Compare(name, "(ReturnValue)", StringComparison.Ordinal) == 0) ? name : ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity2.GetType(), name);
errors.Add(notSetValidationError);
}
else
{
AccessTypes read = AccessTypes.Read;
if ((info2.IsOut || info2.IsRetval) || (info2.Position == -1))
{
read = AccessTypes.Write;
}
ValidationErrorCollection errors3 = System.Workflow.Activities.Common.ValidationHelpers.ValidateProperty(manager, activity, binding, new PropertyValidationContext(activity.ParameterBindings[name], null, name), new BindValidationContext(info2.ParameterType.IsByRef ? info2.ParameterType.GetElementType() : info2.ParameterType, read));
foreach (ValidationError error4 in errors3)
{
if (string.Compare(name, "(ReturnValue)", StringComparison.Ordinal) != 0)
{
error4.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity2.GetType(), name);
}
}
errors.AddRange(errors3);
}
}
if (activity.ParameterBindings.Count > list2.Count)
{
errors.Add(new ValidationError(SR.GetString("Warning_AdditionalBindingsFound"), 0x630, true));
}
}
return(errors);
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
return;
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
Type type = this.ProxyClass;
if (type != null)
{
MethodInfo method = type.GetMethod(this.MethodName);
if (method != null)
{
ArrayList paramInfos = new ArrayList(method.GetParameters());
if (!(method.ReturnType == typeof(void)))
paramInfos.Add(method.ReturnParameter);
foreach (ParameterInfo paramInfo in paramInfos)
{
if (paramInfo.ParameterType != null)
{
PropertyDescriptor prop = null;
if (paramInfo.Position == -1)
prop = new ParameterInfoBasedPropertyDescriptor(typeof(InvokeWebServiceActivity), paramInfo, false, DesignOnlyAttribute.Yes);
else
prop = new ParameterInfoBasedPropertyDescriptor(typeof(InvokeWebServiceActivity), paramInfo, InvokeWebServiceActivity.ReservedParameterNames.Contains(paramInfo.Name), DesignOnlyAttribute.Yes);
// return this parameter
properties[prop.Name] = prop;
}
}
}
}
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
return;
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
if (this.GetType() != typeof(CallExternalMethodActivity))
return; // if custom activity do not add parameter binding
Type type = this.InterfaceType;
if (type == null)
return;
MethodInfo method = type.GetMethod(this.MethodName);
if (method != null)
{
ArrayList paramInfo = new ArrayList(method.GetParameters());
if (!(method.ReturnType == typeof(void)))
paramInfo.Add(method.ReturnParameter);
foreach (ParameterInfo param in paramInfo)
{
if (param.ParameterType != null)
{
PropertyDescriptor prop = new ParameterInfoBasedPropertyDescriptor(typeof(CallExternalMethodActivity), param, true, DesignOnlyAttribute.Yes);
properties[prop.Name] = prop;
}
}
}
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
InvokeWebServiceActivity invokeWebService = obj as InvokeWebServiceActivity;
if (invokeWebService == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(InvokeWebServiceActivity).FullName), "obj");
}
if (invokeWebService.ProxyClass == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "ProxyClass"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "ProxyClass";
validationErrors.Add(error);
}
else
{
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type proxyClassType = invokeWebService.ProxyClass;
// Validate method
if (invokeWebService.MethodName == null || invokeWebService.MethodName.Length == 0)
{
validationErrors.Add(ValidationError.GetNotSetValidationError("MethodName"));
}
else
{
MethodInfo methodInfo = proxyClassType.GetMethod(invokeWebService.MethodName);
if (methodInfo == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_MethodNotExists, "MethodName", invokeWebService.MethodName), ErrorNumbers.Error_MethodNotExists);
error.PropertyName = "MethodName";
validationErrors.Add(error);
}
else
{
ArrayList paramInfos = new ArrayList(methodInfo.GetParameters());
if (methodInfo.ReturnType != typeof(void))
{
paramInfos.Add(methodInfo.ReturnParameter);
}
foreach (ParameterInfo paramInfo in paramInfos)
{
string paramName = paramInfo.Name;
if (paramInfo.Position == -1)
{
paramName = "(ReturnValue)";
}
object paramValue = null;
if (invokeWebService.ParameterBindings.Contains(paramName))
{
if (invokeWebService.ParameterBindings[paramName].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
paramValue = invokeWebService.ParameterBindings[paramName].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
paramValue = invokeWebService.ParameterBindings[paramName].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!invokeWebService.ParameterBindings.Contains(paramName) || paramValue == null)
{
ValidationError validationError = ValidationError.GetNotSetValidationError(paramName);
if (InvokeWebServiceActivity.ReservedParameterNames.Contains(paramName))
{
validationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(invokeWebService.GetType(), paramName);
}
validationError.PropertyName = paramName;
validationErrors.Add(validationError);
}
else
{
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, invokeWebService, paramValue,
new PropertyValidationContext(invokeWebService.ParameterBindings[paramName], null, paramName), new BindValidationContext(paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType, access));
if (InvokeWebServiceActivity.ReservedParameterNames.Contains(paramName))
{
foreach (ValidationError validationError in variableErrors)
{
validationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(invokeWebService.GetType(), paramName);
}
}
validationErrors.AddRange(variableErrors);
}
}
if (invokeWebService.ParameterBindings.Count > paramInfos.Count)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_AdditionalBindingsFound), ErrorNumbers.Warning_AdditionalBindingsFound, true));
}
}
}
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
WebServiceOutputActivity webServiceResponse = obj as WebServiceOutputActivity;
if (webServiceResponse == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(WebServiceOutputActivity).FullName), "obj");
}
if (Helpers.IsActivityLocked(webServiceResponse))
{
return(validationErrors);
}
WebServiceInputActivity webServiceReceive = null;
if (String.IsNullOrEmpty(webServiceResponse.InputActivityName))
{
validationErrors.Add(ValidationError.GetNotSetValidationError("InputActivityName"));
}
else
{
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
bool foundMatchingReceive = false;
foreach (Activity activity in WebServiceActivityHelpers.GetPreceedingActivities(webServiceResponse))
{
if ((activity is WebServiceOutputActivity && String.Compare(((WebServiceOutputActivity)activity).InputActivityName, webServiceResponse.InputActivityName, StringComparison.Ordinal) == 0) ||
(activity is WebServiceFaultActivity && String.Compare(((WebServiceFaultActivity)activity).InputActivityName, webServiceResponse.InputActivityName, StringComparison.Ordinal) == 0))
{
if (activity is WebServiceOutputActivity)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_DuplicateWebServiceResponseFound, activity.QualifiedName, webServiceResponse.InputActivityName), ErrorNumbers.Error_DuplicateWebServiceResponseFound));
}
else
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_DuplicateWebServiceFaultFound, activity.QualifiedName, webServiceResponse.InputActivityName), ErrorNumbers.Error_DuplicateWebServiceFaultFound));
}
return(validationErrors);
}
}
foreach (Activity activity in WebServiceActivityHelpers.GetPreceedingActivities(webServiceResponse))
{
if (String.Compare(activity.QualifiedName, webServiceResponse.InputActivityName, StringComparison.Ordinal) == 0)
{
if (activity is WebServiceInputActivity)
{
webServiceReceive = activity as WebServiceInputActivity;
foundMatchingReceive = true;
}
else
{
foundMatchingReceive = false;
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotValid, webServiceResponse.InputActivityName), ErrorNumbers.Error_WebServiceReceiveNotValid));
return(validationErrors);
}
break;
}
}
if (!foundMatchingReceive)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotFound, webServiceResponse.InputActivityName), ErrorNumbers.Error_WebServiceReceiveNotFound));
return(validationErrors);
}
else
{
Type interfaceType = null;
if (webServiceReceive.InterfaceType != null)
{
interfaceType = typeProvider.GetType(webServiceReceive.InterfaceType.AssemblyQualifiedName);
}
if (interfaceType == null)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotConfigured, webServiceReceive.Name), ErrorNumbers.Error_WebServiceReceiveNotConfigured));
}
else
{
// Validate method
if (String.IsNullOrEmpty(webServiceReceive.MethodName))
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotConfigured, webServiceReceive.Name), ErrorNumbers.Error_WebServiceReceiveNotConfigured));
}
else
{
MethodInfo methodInfo = Helpers.GetInterfaceMethod(interfaceType, webServiceReceive.MethodName);
if (methodInfo == null)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceReceiveNotConfigured, webServiceReceive.Name), ErrorNumbers.Error_WebServiceReceiveNotConfigured));
}
else
{
ValidationErrorCollection parameterTypeErrors = WebServiceActivityHelpers.ValidateParameterTypes(methodInfo);
if (parameterTypeErrors.Count > 0)
{
foreach (ValidationError parameterTypeError in parameterTypeErrors)
{
parameterTypeError.PropertyName = "InputActivityName";
}
validationErrors.AddRange(parameterTypeErrors);
}
else
{
List <ParameterInfo> inputParameters, outParameters;
WebServiceActivityHelpers.GetParameterInfo(methodInfo, out inputParameters, out outParameters);
if (outParameters.Count == 0)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_WebServiceResponseNotNeeded), ErrorNumbers.Error_WebServiceResponseNotNeeded));
}
else
{
// Check to see if all output parameters have a valid bindings.
foreach (ParameterInfo paramInfo in outParameters)
{
string paramName = paramInfo.Name;
Type paramType = paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType;
if (paramInfo.Position == -1)
{
paramName = "(ReturnValue)";
}
object paramValue = null;
if (webServiceResponse.ParameterBindings.Contains(paramName))
{
if (webServiceResponse.ParameterBindings[paramName].IsBindingSet(WorkflowParameterBinding.ValueProperty))
{
paramValue = webServiceResponse.ParameterBindings[paramName].GetBinding(WorkflowParameterBinding.ValueProperty);
}
else
{
paramValue = webServiceResponse.ParameterBindings[paramName].GetValue(WorkflowParameterBinding.ValueProperty);
}
}
if (!paramType.IsPublic || !paramType.IsSerializable)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_TypeNotPublicSerializable, paramName, paramType.FullName), ErrorNumbers.Error_TypeNotPublicSerializable);
validationError.PropertyName = (String.Compare(paramName, "(ReturnValue)", StringComparison.Ordinal) == 0) ? paramName : ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(webServiceReceive.GetType(), paramName);
validationErrors.Add(validationError);
}
else if (!webServiceResponse.ParameterBindings.Contains(paramName) || paramValue == null)
{
ValidationError validationError = ValidationError.GetNotSetValidationError(paramName);
validationError.PropertyName = (String.Compare(paramName, "(ReturnValue)", StringComparison.Ordinal) == 0) ? paramName : ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(webServiceReceive.GetType(), paramName);
validationErrors.Add(validationError);
}
else
{
AccessTypes access = AccessTypes.Read;
if (paramInfo.IsOut || paramInfo.IsRetval || paramInfo.Position == -1)
{
access = AccessTypes.Write;
}
ValidationErrorCollection variableErrors = ValidationHelpers.ValidateProperty(manager, webServiceResponse, paramValue,
new PropertyValidationContext(webServiceResponse.ParameterBindings[paramName], null, paramName), new BindValidationContext(paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType, access));
foreach (ValidationError variableError in variableErrors)
{
if (String.Compare(paramName, "(ReturnValue)", StringComparison.Ordinal) != 0)
{
variableError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(webServiceReceive.GetType(), paramName);
}
}
validationErrors.AddRange(variableErrors);
}
}
if (webServiceResponse.ParameterBindings.Count > outParameters.Count)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_AdditionalBindingsFound), ErrorNumbers.Warning_AdditionalBindingsFound, true));
}
}
}
}
}
}
}
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
InvokeWorkflowActivity invokeWorkflow = obj as InvokeWorkflowActivity;
if (invokeWorkflow == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(InvokeWorkflowActivity).FullName), "obj");
}
if (invokeWorkflow.TargetWorkflow == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "TargetWorkflow"), ErrorNumbers.Error_PropertyNotSet);
error.PropertyName = "TargetWorkflow";
validationErrors.Add(error);
}
else
{
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (typeProvider == null)
{
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
}
Type targetWorkflowType = invokeWorkflow.TargetWorkflow;
if (targetWorkflowType.Assembly == null && typeProvider.LocalAssembly != null)
{
Type workflowType = typeProvider.LocalAssembly.GetType(targetWorkflowType.FullName);
if (workflowType != null)
{
targetWorkflowType = workflowType;
}
}
if (!TypeProvider.IsAssignable(typeof(Activity), targetWorkflowType))
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_TypeIsNotRootActivity, "TargetWorkflow"), ErrorNumbers.Error_TypeIsNotRootActivity);
error.PropertyName = "TargetWorkflow";
validationErrors.Add(error);
}
else
{
Activity rootActivity = null;
try
{
rootActivity = Activator.CreateInstance(targetWorkflowType) as Activity;
}
catch (Exception)
{
//
}
if (rootActivity == null)
{
ValidationError error = new ValidationError(SR.GetString(SR.Error_GetCalleeWorkflow, invokeWorkflow.TargetWorkflow), ErrorNumbers.Error_GetCalleeWorkflow);
error.PropertyName = "TargetWorkflow";
validationErrors.Add(error);
}
else
{
// Exec can't have activate receive.
Walker walker = new Walker();
walker.FoundActivity += delegate(Walker w, WalkerEventArgs args)
{
if ((args.CurrentActivity is WebServiceInputActivity && ((WebServiceInputActivity)args.CurrentActivity).IsActivating))
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_ExecWithActivationReceive), ErrorNumbers.Error_ExecWithActivationReceive);
validationError.PropertyName = "Name";
validationErrors.Add(validationError);
args.Action = WalkerAction.Abort;
}
};
walker.Walk((Activity)rootActivity);
bool inAtomicScope = false;
Activity parentScope = invokeWorkflow.Parent;
while (parentScope != null)
{
if (parentScope is CompensatableTransactionScopeActivity || parentScope is TransactionScopeActivity)
{
inAtomicScope = true;
break;
}
parentScope = parentScope.Parent;
}
// Validate that if the workflow is transactional or being exec'd then it is not enclosed in an atomic scope.
if (inAtomicScope)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_ExecInAtomicScope), ErrorNumbers.Error_ExecInAtomicScope);
validationErrors.Add(validationError);
}
foreach (WorkflowParameterBinding paramBinding in invokeWorkflow.ParameterBindings)
{
PropertyInfo propertyInfo = null;
propertyInfo = targetWorkflowType.GetProperty(paramBinding.ParameterName);
if (propertyInfo == null)
{
ValidationError validationError = new ValidationError(SR.GetString(SR.Error_ParameterNotFound, paramBinding.ParameterName), ErrorNumbers.Error_ParameterNotFound);
if (InvokeWorkflowActivity.ReservedParameterNames.Contains(paramBinding.ParameterName))
{
validationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(invokeWorkflow.GetType(), paramBinding.ParameterName);
}
validationErrors.Add(validationError);
continue;
}
Type parameterType = propertyInfo.PropertyType;
if (paramBinding.GetBinding(WorkflowParameterBinding.ValueProperty) != null)
{
ValidationErrorCollection memberErrors = ValidationHelpers.ValidateProperty(manager, invokeWorkflow, paramBinding.GetBinding(WorkflowParameterBinding.ValueProperty), new PropertyValidationContext(paramBinding, null, paramBinding.ParameterName), new BindValidationContext(parameterType, AccessTypes.Read));
if (memberErrors.Count != 0)
{
validationErrors.AddRange(memberErrors);
continue;
}
}
}
}
}
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
System.Workflow.Activities.Common.WalkerEventHandler handler = null;
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
InvokeWorkflowActivity activity = obj as InvokeWorkflowActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(InvokeWorkflowActivity).FullName }), "obj");
}
if (activity.TargetWorkflow == null)
{
ValidationError error = new ValidationError(SR.GetString("Error_TypePropertyInvalid", new object[] { "TargetWorkflow" }), 0x116)
{
PropertyName = "TargetWorkflow"
};
validationErrors.Add(error);
return(validationErrors);
}
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
if (service == null)
{
throw new InvalidOperationException(SR.GetString("General_MissingService", new object[] { typeof(ITypeProvider).FullName }));
}
Type targetWorkflow = activity.TargetWorkflow;
if ((targetWorkflow.Assembly == null) && (service.LocalAssembly != null))
{
Type type = service.LocalAssembly.GetType(targetWorkflow.FullName);
if (type != null)
{
targetWorkflow = type;
}
}
if (!TypeProvider.IsAssignable(typeof(Activity), targetWorkflow))
{
ValidationError error2 = new ValidationError(SR.GetString("Error_TypeIsNotRootActivity", new object[] { "TargetWorkflow" }), 0x60e)
{
PropertyName = "TargetWorkflow"
};
validationErrors.Add(error2);
return(validationErrors);
}
Activity seedActivity = null;
try
{
seedActivity = Activator.CreateInstance(targetWorkflow) as Activity;
}
catch (Exception)
{
}
if (seedActivity == null)
{
ValidationError error3 = new ValidationError(SR.GetString("Error_GetCalleeWorkflow", new object[] { activity.TargetWorkflow }), 0x500)
{
PropertyName = "TargetWorkflow"
};
validationErrors.Add(error3);
return(validationErrors);
}
System.Workflow.Activities.Common.Walker walker = new System.Workflow.Activities.Common.Walker();
if (handler == null)
{
handler = delegate(System.Workflow.Activities.Common.Walker w, System.Workflow.Activities.Common.WalkerEventArgs args) {
if ((args.CurrentActivity is WebServiceInputActivity) && ((WebServiceInputActivity)args.CurrentActivity).IsActivating)
{
ValidationError item = new ValidationError(SR.GetString("Error_ExecWithActivationReceive"), 0x614)
{
PropertyName = "Name"
};
validationErrors.Add(item);
args.Action = System.Workflow.Activities.Common.WalkerAction.Abort;
}
};
}
walker.FoundActivity += handler;
walker.Walk(seedActivity);
bool flag = false;
for (Activity activity3 = activity.Parent; activity3 != null; activity3 = activity3.Parent)
{
if ((activity3 is CompensatableTransactionScopeActivity) || (activity3 is TransactionScopeActivity))
{
flag = true;
break;
}
}
if (flag)
{
ValidationError error4 = new ValidationError(SR.GetString("Error_ExecInAtomicScope"), 0x502);
validationErrors.Add(error4);
}
foreach (WorkflowParameterBinding binding in activity.ParameterBindings)
{
PropertyInfo property = null;
property = targetWorkflow.GetProperty(binding.ParameterName);
if (property == null)
{
ValidationError error5 = new ValidationError(SR.GetString("Error_ParameterNotFound", new object[] { binding.ParameterName }), 0x504);
if (InvokeWorkflowActivity.ReservedParameterNames.Contains(binding.ParameterName))
{
error5.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(activity.GetType(), binding.ParameterName);
}
validationErrors.Add(error5);
}
else
{
Type propertyType = property.PropertyType;
if (binding.GetBinding(WorkflowParameterBinding.ValueProperty) != null)
{
ValidationErrorCollection errors = System.Workflow.Activities.Common.ValidationHelpers.ValidateProperty(manager, activity, binding.GetBinding(WorkflowParameterBinding.ValueProperty), new PropertyValidationContext(binding, null, binding.ParameterName), new BindValidationContext(propertyType, AccessTypes.Read));
if (errors.Count != 0)
{
validationErrors.AddRange(errors);
}
}
}
}
return(validationErrors);
}
internal void GetParameterPropertyDescriptors(IDictionary properties)
{
if (((IComponent)this).Site == null)
return;
ITypeProvider typeProvider = (ITypeProvider)((IComponent)this).Site.GetService(typeof(ITypeProvider));
if (typeProvider == null)
throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName));
if (this.InputActivityName != null && !String.IsNullOrEmpty(this.InputActivityName.Trim()))
{
WebServiceInputActivity webServiceReceive = Helpers.ParseActivity(Helpers.GetRootActivity(this), this.InputActivityName) as WebServiceInputActivity;
if (webServiceReceive != null)
{
Type type = null;
if (webServiceReceive.InterfaceType != null)
type = typeProvider.GetType(webServiceReceive.InterfaceType.AssemblyQualifiedName);
if (type != null)
{
MethodInfo method = Helpers.GetInterfaceMethod(type, webServiceReceive.MethodName);
if (method != null && WebServiceActivityHelpers.ValidateParameterTypes(method).Count == 0)
{
List<ParameterInfo> inputParameters, outParameters;
WebServiceActivityHelpers.GetParameterInfo(method, out inputParameters, out outParameters);
foreach (ParameterInfo paramInfo in outParameters)
{
PropertyDescriptor prop = null;
if (paramInfo.Position == -1)
prop = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceOutputActivity), paramInfo, false, DesignOnlyAttribute.Yes);
else
prop = new ParameterInfoBasedPropertyDescriptor(typeof(WebServiceOutputActivity), paramInfo, true, DesignOnlyAttribute.Yes);
if (prop != null)
properties[prop.Name] = prop;
}
}
}
}
}
}
