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