Ejemplo n.º 1
0
        public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
        {
            ValidationErrorCollection validationErrors = base.Validate(manager, obj);

            ActivityBind bind = obj as ActivityBind;
            if (bind == null)
                throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(ActivityBind).FullName), "obj");

            Activity activity = manager.Context[typeof(Activity)] as Activity;
            if (activity == null)
                throw new InvalidOperationException(SR.GetString(SR.Error_ContextStackItemMissing, typeof(Activity).Name));

            PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;
            if (validationContext == null)
                throw new InvalidOperationException(SR.GetString(SR.Error_ContextStackItemMissing, typeof(BindValidationContext).Name));

            ValidationError error = null;
            if (string.IsNullOrEmpty(bind.Name))
            {
                error = new ValidationError(SR.GetString(SR.Error_IDNotSetForActivitySource), ErrorNumbers.Error_IDNotSetForActivitySource);
                error.PropertyName = GetFullPropertyName(manager) + ".Name";
                validationErrors.Add(error);
            }
            else
            {
                Activity refActivity = Helpers.ParseActivityForBind(activity, bind.Name);
                if (refActivity == null)
                {
                    if (bind.Name.StartsWith("/"))
                        error = new ValidationError(SR.GetString(SR.Error_CannotResolveRelativeActivity, bind.Name), ErrorNumbers.Error_CannotResolveRelativeActivity);
                    else
                        error = new ValidationError(SR.GetString(SR.Error_CannotResolveActivity, bind.Name), ErrorNumbers.Error_CannotResolveActivity);
                    error.PropertyName = GetFullPropertyName(manager) + ".Name";
                    validationErrors.Add(error);
                }

                if (String.IsNullOrEmpty(bind.Path))
                {
                    error = new ValidationError(SR.GetString(SR.Error_PathNotSetForActivitySource), ErrorNumbers.Error_PathNotSetForActivitySource);
                    error.PropertyName = GetFullPropertyName(manager) + ".Path";
                    validationErrors.Add(error);
                }

                if (refActivity != null && validationErrors.Count == 0)
                {
                    string memberName = bind.Path;
                    string path = String.Empty;
                    int indexOfSeparator = memberName.IndexOfAny(new char[] { '.', '/', '[' });
                    if (indexOfSeparator != -1)
                    {
                        path = memberName.Substring(indexOfSeparator);
                        path = path.StartsWith(".") ? path.Substring(1) : path;
                        memberName = memberName.Substring(0, indexOfSeparator);
                    }

                    Type baseType = BindHelpers.GetBaseType(manager, validationContext);

                    //We need to bifurcate to field, method, property or ActivityBind, we need to distinguish based on first
                    //part of the path
                    MemberInfo memberInfo = null;
                    Type declaringType = null;

                    if (!String.IsNullOrEmpty(memberName))
                    {
                        declaringType = BindValidatorHelper.GetActivityType(manager, refActivity);
                        if (declaringType != null)
                        {
                            memberInfo = MemberBind.GetMemberInfo(declaringType, memberName);

                            //it could be an indexer property that requires [..] part to get correctly resolved
                            if (memberInfo == null && path.StartsWith("[", StringComparison.Ordinal))
                            {
                                string indexerPart = bind.Path.Substring(indexOfSeparator);
                                int closingBracketIndex = indexerPart.IndexOf(']');
                                if (closingBracketIndex != -1)
                                {
                                    string firstIndexerPart = indexerPart.Substring(0, closingBracketIndex + 1); //strip potential long path like Item[0].Foo
                                    path = (closingBracketIndex + 1 < indexerPart.Length) ? indexerPart.Substring(closingBracketIndex + 1) : string.Empty;
                                    path = path.StartsWith(".") ? path.Substring(1) : path;
                                    indexerPart = firstIndexerPart;
                                }
                                memberName = memberName + indexerPart;
                                memberInfo = MemberBind.GetMemberInfo(declaringType, memberName);
                            }
                        }
                    }

                    Validator validator = null;
                    object actualBind = null; //now there are two different class hierarchies - ActivityBind is not related to the BindBase/MemberBind
                    if (memberInfo != null)
                    {
                        string qualifier = (!String.IsNullOrEmpty(refActivity.QualifiedName)) ? refActivity.QualifiedName : bind.Name;

                        if (memberInfo is FieldInfo)
                        {
                            actualBind = new FieldBind(qualifier + "." + memberName, path);
                            validator = new FieldBindValidator();
                        }
                        else if (memberInfo is MethodInfo)
                        {
                            if (typeof(Delegate).IsAssignableFrom(baseType))
                            {
                                actualBind = new MethodBind(qualifier + "." + memberName);
                                validator = new MethodBindValidator();
                            }
                            else
                            {
                                error = new ValidationError(SR.GetString(SR.Error_InvalidMemberType, memberName, GetFullPropertyName(manager)), ErrorNumbers.Error_InvalidMemberType);
                                error.PropertyName = GetFullPropertyName(manager);
                                validationErrors.Add(error);
                            }
                        }
                        else if (memberInfo is PropertyInfo)
                        {
                            //Only if the referenced activity is the same it is a PropertyBind otherwise it is a ActivityBind
                            if (refActivity == activity)
                            {
                                actualBind = new PropertyBind(qualifier + "." + memberName, path);
                                validator = new PropertyBindValidator();
                            }
                            else
                            {
                                actualBind = bind;
                                validator = this;
                            }
                        }
                        else if (memberInfo is EventInfo)
                        {
                            actualBind = bind;
                            validator = this;
                        }
                    }
                    else if (memberInfo == null && baseType != null && typeof(Delegate).IsAssignableFrom(baseType))
                    {
                        actualBind = bind;
                        validator = this;
                    }

                    if (validator != null && actualBind != null)
                    {
                        if (validator == this && actualBind is ActivityBind)
                            validationErrors.AddRange(ValidateActivityBind(manager, actualBind));
                        else
                            validationErrors.AddRange(validator.Validate(manager, actualBind));
                    }
                    else if (error == null)
                    {
                        error = new ValidationError(SR.GetString(SR.Error_PathCouldNotBeResolvedToMember, bind.Path, (!string.IsNullOrEmpty(refActivity.QualifiedName)) ? refActivity.QualifiedName : refActivity.GetType().Name), ErrorNumbers.Error_PathCouldNotBeResolvedToMember);
                        error.PropertyName = GetFullPropertyName(manager);
                        validationErrors.Add(error);
                    }
                }
            }

            return validationErrors;
        }
Ejemplo n.º 2
0
        public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
        {
            ValidationErrorCollection errors = base.Validate(manager, obj);
            ActivityBind bind = obj as ActivityBind;

            if (bind == null)
            {
                throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(ActivityBind).FullName }), "obj");
            }
            Activity activity = manager.Context[typeof(Activity)] as Activity;

            if (activity == null)
            {
                throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(Activity).Name }));
            }
            PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;

            if (validationContext == null)
            {
                throw new InvalidOperationException(SR.GetString("Error_ContextStackItemMissing", new object[] { typeof(BindValidationContext).Name }));
            }
            ValidationError item = null;

            if (string.IsNullOrEmpty(bind.Name))
            {
                item = new ValidationError(SR.GetString("Error_IDNotSetForActivitySource"), 0x613)
                {
                    PropertyName = base.GetFullPropertyName(manager) + ".Name"
                };
                errors.Add(item);
                return(errors);
            }
            Activity refActivity = Helpers.ParseActivityForBind(activity, bind.Name);

            if (refActivity == null)
            {
                if (bind.Name.StartsWith("/"))
                {
                    item = new ValidationError(SR.GetString("Error_CannotResolveRelativeActivity", new object[] { bind.Name }), 0x128);
                }
                else
                {
                    item = new ValidationError(SR.GetString("Error_CannotResolveActivity", new object[] { bind.Name }), 0x129);
                }
                item.PropertyName = base.GetFullPropertyName(manager) + ".Name";
                errors.Add(item);
            }
            if (string.IsNullOrEmpty(bind.Path))
            {
                item = new ValidationError(SR.GetString("Error_PathNotSetForActivitySource"), 0x12b)
                {
                    PropertyName = base.GetFullPropertyName(manager) + ".Path"
                };
                errors.Add(item);
            }
            if ((refActivity != null) && (errors.Count == 0))
            {
                string path       = bind.Path;
                string str2       = string.Empty;
                int    startIndex = path.IndexOfAny(new char[] { '.', '/', '[' });
                if (startIndex != -1)
                {
                    str2 = path.Substring(startIndex);
                    str2 = str2.StartsWith(".") ? str2.Substring(1) : str2;
                    path = path.Substring(0, startIndex);
                }
                Type       baseType   = BindHelpers.GetBaseType(manager, validationContext);
                MemberInfo memberInfo = null;
                Type       srcType    = null;
                if (!string.IsNullOrEmpty(path))
                {
                    srcType = BindValidatorHelper.GetActivityType(manager, refActivity);
                    if (srcType != null)
                    {
                        memberInfo = MemberBind.GetMemberInfo(srcType, path);
                        if ((memberInfo == null) && str2.StartsWith("[", StringComparison.Ordinal))
                        {
                            string str3  = bind.Path.Substring(startIndex);
                            int    index = str3.IndexOf(']');
                            if (index != -1)
                            {
                                string str4 = str3.Substring(0, index + 1);
                                str2 = ((index + 1) < str3.Length) ? str3.Substring(index + 1) : string.Empty;
                                str2 = str2.StartsWith(".") ? str2.Substring(1) : str2;
                                str3 = str4;
                            }
                            path       = path + str3;
                            memberInfo = MemberBind.GetMemberInfo(srcType, path);
                        }
                    }
                }
                Validator validator = null;
                object    obj2      = null;
                if (memberInfo != null)
                {
                    string str5 = !string.IsNullOrEmpty(refActivity.QualifiedName) ? refActivity.QualifiedName : bind.Name;
                    if (memberInfo is FieldInfo)
                    {
                        obj2      = new FieldBind(str5 + "." + path, str2);
                        validator = new FieldBindValidator();
                    }
                    else if (memberInfo is MethodInfo)
                    {
                        if (typeof(Delegate).IsAssignableFrom(baseType))
                        {
                            obj2      = new MethodBind(str5 + "." + path);
                            validator = new MethodBindValidator();
                        }
                        else
                        {
                            item = new ValidationError(SR.GetString("Error_InvalidMemberType", new object[] { path, base.GetFullPropertyName(manager) }), 0x629)
                            {
                                PropertyName = base.GetFullPropertyName(manager)
                            };
                            errors.Add(item);
                        }
                    }
                    else if (memberInfo is PropertyInfo)
                    {
                        if (refActivity == activity)
                        {
                            obj2      = new PropertyBind(str5 + "." + path, str2);
                            validator = new PropertyBindValidator();
                        }
                        else
                        {
                            obj2      = bind;
                            validator = this;
                        }
                    }
                    else if (memberInfo is EventInfo)
                    {
                        obj2      = bind;
                        validator = this;
                    }
                }
                else if (((memberInfo == null) && (baseType != null)) && typeof(Delegate).IsAssignableFrom(baseType))
                {
                    obj2      = bind;
                    validator = this;
                }
                if ((validator != null) && (obj2 != null))
                {
                    if ((validator == this) && (obj2 is ActivityBind))
                    {
                        errors.AddRange(this.ValidateActivityBind(manager, obj2));
                        return(errors);
                    }
                    errors.AddRange(validator.Validate(manager, obj2));
                    return(errors);
                }
                if (item == null)
                {
                    item = new ValidationError(SR.GetString("Error_PathCouldNotBeResolvedToMember", new object[] { bind.Path, !string.IsNullOrEmpty(refActivity.QualifiedName) ? refActivity.QualifiedName : refActivity.GetType().Name }), 0x60d)
                    {
                        PropertyName = base.GetFullPropertyName(manager)
                    };
                    errors.Add(item);
                }
            }
            return(errors);
        }