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