C# RuleValidation.AddError方法代碼示例

 private bool ValidateInvokeAttribute(RuleValidation validation, MemberInfo member, Type contextType, Stack<MemberInfo> methodStack)
 {
     ValidationError error;
     if (string.IsNullOrEmpty(this.methodInvoked))
     {
         error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.AttributeMethodNotFound, new object[] { member.Name, base.GetType().Name, Messages.NullValue }), 0x56b, true);
         error.UserData["ErrorObject"] = this;
         validation.AddError(error);
         return false;
     }
     bool flag = true;
     MemberInfo[] infoArray = contextType.GetMember(this.methodInvoked, MemberTypes.Property | MemberTypes.Method, BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
     if ((infoArray == null) || (infoArray.Length == 0))
     {
         error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.AttributeMethodNotFound, new object[] { member.Name, base.GetType().Name, this.methodInvoked }), 0x56b, true);
         error.UserData["ErrorObject"] = this;
         validation.AddError(error);
         return false;
     }
     for (int i = 0; i < infoArray.Length; i++)
     {
         MemberInfo item = infoArray[i];
         if (!methodStack.Contains(item))
         {
             methodStack.Push(item);
             object[] customAttributes = item.GetCustomAttributes(typeof(RuleAttribute), true);
             if ((customAttributes != null) && (customAttributes.Length != 0))
             {
                 foreach (RuleAttribute attribute in customAttributes)
                 {
                     RuleReadWriteAttribute attribute2 = attribute as RuleReadWriteAttribute;
                     if (attribute2 != null)
                     {
                         if (attribute2.Target == RuleAttributeTarget.Parameter)
                         {
                             error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvokeAttrRefersToParameterAttribute, new object[] { item.Name }), 0x1a5, true);
                             error.UserData["ErrorObject"] = this;
                             validation.AddError(error);
                             flag = false;
                         }
                         else
                         {
                             attribute2.Validate(validation, item, contextType, null);
                         }
                     }
                     else
                     {
                         ((RuleInvokeAttribute) attribute).ValidateInvokeAttribute(validation, item, contextType, methodStack);
                     }
                 }
             }
             methodStack.Pop();
         }
     }
     return flag;
 }

        internal override bool Validate(RuleValidation validation, MemberInfo member, Type contextType, ParameterInfo[] parameters)
        {
            ValidationError error = null;
            string message = null;

            if (string.IsNullOrEmpty(attributePath))
            {
                // It is allowed to pass null or the empty string to [RuleRead] or [RuleWrite].  This
                // is how you indicate that a method or property has no dependencies or side effects.
                return true;
            }

            bool valid = true;

            string[] parts = attributePath.Split('/');

            // Check the first part.

            string firstPart = parts[0];
            int startOfRelativePortion = 0;
            if (attributeTarget == RuleAttributeTarget.This)
            {
                // When target is "This", the path is allowed to start with the token "this".  It is
                // then skipped for the rest of the validation, and the contextType remains what it
                // was when passed in.
                if (firstPart == "this")
                    ++startOfRelativePortion;
            }
            else
            {
                // When target is "Parameter", the path must start with the name of a parameter.
                bool found = false;
                for (int p = 0; p < parameters.Length; ++p)
                {
                    ParameterInfo param = parameters[p];
                    if (param.Name == firstPart)
                    {
                        found = true;

                        // The context type is the parameter type.
                        contextType = param.ParameterType;
                        break;
                    }
                }

                if (!found)
                {
                    message = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleAttributeParameter, firstPart, member.Name);
                    error = new ValidationError(message, ErrorNumbers.Error_InvalidRuleAttributeParameter);
                    error.UserData[RuleUserDataKeys.ErrorObject] = this;
                    validation.AddError(error);
                    return false;
                }

                ++startOfRelativePortion;
            }

            int numParts = parts.Length;

            // Check the last part.  The last part is allowed to be empty, or "*".

            string lastPart = parts[numParts - 1];
            if (string.IsNullOrEmpty(lastPart) || lastPart == "*")
                numParts -= 1;

            // Check the rest of the parts.

            Type currentType = contextType;
            for (int i = startOfRelativePortion; i < numParts; ++i)
            {
                // Can't have embedded "*" wildcards.
                if (parts[i] == "*")
                {
                    // The "*" occurred in the middle of the path, which is a no-no.
                    error = new ValidationError(Messages.InvalidWildCardInPathQualifier, ErrorNumbers.Error_InvalidWildCardInPathQualifier);
                    error.UserData[RuleUserDataKeys.ErrorObject] = this;
                    validation.AddError(error);
                    valid = false;
                    break;
                }

                // Skip array types.
                while (currentType.IsArray)
                    currentType = currentType.GetElementType();

                // Make sure the member exists in the current type.
                BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy;
                if (validation.AllowInternalMembers(currentType))
                    bindingFlags |= BindingFlags.NonPublic;

                FieldInfo field = currentType.GetField(parts[i], bindingFlags);
                if (field != null)
                {
                    currentType = field.FieldType;
                }
                else
                {
                    PropertyInfo property = currentType.GetProperty(parts[i], bindingFlags);
                    if (property != null)
                    {
//.........這裏部分代碼省略.........

 public override bool Validate(RuleValidation validator)
 {
     if (validator == null)
     {
         throw new ArgumentNullException("validator");
     }
     if (this.codeDomStatement == null)
     {
         ValidationError error = new ValidationError(Messages.NullStatement, 0x53d);
         error.UserData["ErrorObject"] = this;
         validator.AddError(error);
         return false;
     }
     return CodeDomStatementWalker.Validate(validator, this.codeDomStatement);
 }

        private bool ValidateInvokeAttribute(RuleValidation validation, MemberInfo member, Type contextType, Stack<MemberInfo> methodStack)
        {
            string message;
            ValidationError error;

            if (string.IsNullOrEmpty(methodInvoked))
            {
                // Invoked method or property name was null or empty.
                message = string.Format(CultureInfo.CurrentCulture, Messages.AttributeMethodNotFound, member.Name, this.GetType().Name, Messages.NullValue);
                error = new ValidationError(message, ErrorNumbers.Warning_RuleAttributeNoMatch, true);
                error.UserData[RuleUserDataKeys.ErrorObject] = this;
                validation.AddError(error);
                return false;
            }

            bool valid = true;

            // Go through all the methods and properties on the target context,
            // looking for all the ones that match the name on the attribute.
            MemberInfo[] members = contextType.GetMember(methodInvoked, MemberTypes.Method | MemberTypes.Property, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

            if (members == null || members.Length == 0)
            {
                // Invoked method or property didn't exist.
                message = string.Format(CultureInfo.CurrentCulture, Messages.AttributeMethodNotFound, member.Name, this.GetType().Name, methodInvoked);
                error = new ValidationError(message, ErrorNumbers.Warning_RuleAttributeNoMatch, true);
                error.UserData[RuleUserDataKeys.ErrorObject] = this;
                validation.AddError(error);
                valid = false;
            }
            else
            {
                for (int i = 0; i < members.Length; ++i)
                {
                    MemberInfo mi = members[i];
                    if (!methodStack.Contains(mi)) // Prevent recursion
                    {
                        methodStack.Push(mi);

                        object[] attrs = mi.GetCustomAttributes(typeof(RuleAttribute), true);
                        if (attrs != null && attrs.Length != 0)
                        {
                            foreach (RuleAttribute invokedRuleAttr in attrs)
                            {
                                RuleReadWriteAttribute readWriteAttr = invokedRuleAttr as RuleReadWriteAttribute;
                                if (readWriteAttr != null)
                                {
                                    // This read/write attribute may not specify a target of "Parameter", since
                                    // we can't map from the invoker's parameters to the invokee's parameters.
                                    if (readWriteAttr.Target == RuleAttributeTarget.Parameter)
                                    {
                                        message = string.Format(CultureInfo.CurrentCulture, Messages.InvokeAttrRefersToParameterAttribute, mi.Name);
                                        error = new ValidationError(message, ErrorNumbers.Error_InvokeAttrRefersToParameterAttribute, true);
                                        error.UserData[RuleUserDataKeys.ErrorObject] = this;
                                        validation.AddError(error);
                                        valid = false;
                                    }
                                    else
                                    {
                                        // Validate the read/write attribute normally.
                                        readWriteAttr.Validate(validation, mi, contextType, null);
                                    }
                                }
                                else
                                {
                                    RuleInvokeAttribute invokeAttr = (RuleInvokeAttribute)invokedRuleAttr;
                                    invokeAttr.ValidateInvokeAttribute(validation, mi, contextType, methodStack);
                                }
                            }
                        }

                        methodStack.Pop();
                    }
                }
            }

            return valid;
        }

        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            ValidationError error;
            CodeBinaryOperatorExpression newParent = (CodeBinaryOperatorExpression) expression;
            if (!validation.PushParentExpression(newParent))
            {
                return null;
            }
            if (isWritten)
            {
                error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeBinaryOperatorExpression).ToString() }), 0x17a);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
            }
            RuleExpressionInfo info = null;
            RuleExpressionInfo info2 = null;
            if (newParent.Left == null)
            {
                error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullBinaryOpLHS, new object[] { newParent.Operator.ToString() }), 0x541);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
            }
            else
            {
                if (newParent.Left is CodeTypeReferenceExpression)
                {
                    error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { newParent.Left.GetType().FullName }), 0x548);
                    error.UserData["ErrorObject"] = newParent.Left;
                    validation.AddError(error);
                    return null;
                }
                info = RuleExpressionWalker.Validate(validation, newParent.Left, false);
            }
            if (newParent.Right == null)
            {
                error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullBinaryOpRHS, new object[] { newParent.Operator.ToString() }), 0x543);
                error.UserData["ErrorObject"] = newParent;
                validation.Errors.Add(error);
            }
            else
            {
                if (newParent.Right is CodeTypeReferenceExpression)
                {
                    error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { newParent.Right.GetType().FullName }), 0x548);
                    error.UserData["ErrorObject"] = newParent.Right;
                    validation.AddError(error);
                    return null;
                }
                info2 = RuleExpressionWalker.Validate(validation, newParent.Right, false);
            }
            validation.PopParentExpression();
            RuleBinaryExpressionInfo info3 = null;
            if ((info != null) && (info2 != null))
            {
                Type expressionType = info.ExpressionType;
                Type rhs = info2.ExpressionType;
                switch (newParent.Operator)
                {
                    case CodeBinaryOperatorType.Add:
                    case CodeBinaryOperatorType.Subtract:
                    case CodeBinaryOperatorType.Multiply:
                    case CodeBinaryOperatorType.Divide:
                    case CodeBinaryOperatorType.Modulus:
                    case CodeBinaryOperatorType.BitwiseOr:
                    case CodeBinaryOperatorType.BitwiseAnd:
                        info3 = ArithmeticLiteral.ResultType(newParent.Operator, expressionType, newParent.Left, rhs, newParent.Right, validation, out error);
                        if (info3 == null)
                        {
                            if ((!(expressionType == typeof(ulong)) || !PromotionPossible(rhs, newParent.Right)) && (!(rhs == typeof(ulong)) || !PromotionPossible(expressionType, newParent.Left)))
                            {
                                error.UserData["ErrorObject"] = newParent;
                                validation.Errors.Add(error);
                            }
                            else
                            {
                                info3 = new RuleBinaryExpressionInfo(expressionType, rhs, typeof(ulong));
                            }
                        }
                        goto Label_063E;

                    case CodeBinaryOperatorType.IdentityInequality:
                    case CodeBinaryOperatorType.IdentityEquality:
                        info3 = new RuleBinaryExpressionInfo(expressionType, rhs, typeof(bool));
                        goto Label_063E;

                    case CodeBinaryOperatorType.ValueEquality:
                        info3 = Literal.AllowedComparison(expressionType, newParent.Left, rhs, newParent.Right, newParent.Operator, validation, out error);
                        if (info3 == null)
                        {
                            if ((!(expressionType == typeof(ulong)) || !PromotionPossible(rhs, newParent.Right)) && (!(rhs == typeof(ulong)) || !PromotionPossible(expressionType, newParent.Left)))
                            {
                                error.UserData["ErrorObject"] = newParent;
                                validation.Errors.Add(error);
                            }
                            else
                            {
                                info3 = new RuleBinaryExpressionInfo(expressionType, rhs, typeof(bool));
                            }
                        }
                        goto Label_063E;
//.........這裏部分代碼省略.........

        public override bool Validate(RuleValidation validator)
        {
            if (validator == null)
                throw new ArgumentNullException("validator");

            if (codeDomStatement == null)
            {
                ValidationError error = new ValidationError(Messages.NullStatement, ErrorNumbers.Error_ParameterNotSet);
                error.UserData[RuleUserDataKeys.ErrorObject] = this;
                validator.AddError(error);
                return false;
            }
            else
            {
                return CodeDomStatementWalker.Validate(validator, codeDomStatement);
            }
        }

        internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
        {
            string message;
            ValidationError error;

            CodeBinaryOperatorExpression binaryExpr = (CodeBinaryOperatorExpression)expression;

            // Early exit from this if a cycle is detected.
            if (!validation.PushParentExpression(binaryExpr))
                return null;

            if (isWritten)
            {
                message = string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, typeof(CodeBinaryOperatorExpression).ToString());
                error = new ValidationError(message, ErrorNumbers.Error_InvalidAssignTarget);
                error.UserData[RuleUserDataKeys.ErrorObject] = binaryExpr;
                validation.Errors.Add(error);
            }

            RuleExpressionInfo lhsExprInfo = null;
            RuleExpressionInfo rhsExprInfo = null;

            if (binaryExpr.Left == null)
            {
                message = string.Format(CultureInfo.CurrentCulture, Messages.NullBinaryOpLHS, binaryExpr.Operator.ToString());
                error = new ValidationError(message, ErrorNumbers.Error_LeftOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = binaryExpr;
                validation.Errors.Add(error);
            }
            else
            {
                if (binaryExpr.Left is CodeTypeReferenceExpression)
                {
                    message = string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, binaryExpr.Left.GetType().FullName);
                    error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled);
                    error.UserData[RuleUserDataKeys.ErrorObject] = binaryExpr.Left;
                    validation.AddError(error);
                    return null;
                }

                lhsExprInfo = RuleExpressionWalker.Validate(validation, binaryExpr.Left, false);
            }

            if (binaryExpr.Right == null)
            {
                message = string.Format(CultureInfo.CurrentCulture, Messages.NullBinaryOpRHS, binaryExpr.Operator.ToString());
                error = new ValidationError(message, ErrorNumbers.Error_RightOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = binaryExpr;
                validation.Errors.Add(error);
            }
            else
            {
                if (binaryExpr.Right is CodeTypeReferenceExpression)
                {
                    message = string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, binaryExpr.Right.GetType().FullName);
                    error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled);
                    error.UserData[RuleUserDataKeys.ErrorObject] = binaryExpr.Right;
                    validation.AddError(error);
                    return null;
                }

                rhsExprInfo = RuleExpressionWalker.Validate(validation, binaryExpr.Right, false);
            }

            validation.PopParentExpression();

            RuleBinaryExpressionInfo resultExprInfo = null;

            if (lhsExprInfo != null && rhsExprInfo != null)
            {
                Type lhsType = lhsExprInfo.ExpressionType;
                Type rhsType = rhsExprInfo.ExpressionType;

                switch (binaryExpr.Operator)
                {
                    case CodeBinaryOperatorType.Add:
                    case CodeBinaryOperatorType.Subtract:
                    case CodeBinaryOperatorType.Multiply:
                    case CodeBinaryOperatorType.Divide:
                    case CodeBinaryOperatorType.Modulus:
                    case CodeBinaryOperatorType.BitwiseAnd:
                    case CodeBinaryOperatorType.BitwiseOr:
                        resultExprInfo = ArithmeticLiteral.ResultType(binaryExpr.Operator, lhsType, binaryExpr.Left, rhsType, binaryExpr.Right, validation, out error);
                        if (resultExprInfo == null)
                        {
                            // check if constants are used with ulongs, as we should do some extra "conversions"
                            if (((lhsType == typeof(ulong)) && (PromotionPossible(rhsType, binaryExpr.Right)))
                                || ((rhsType == typeof(ulong)) && (PromotionPossible(lhsType, binaryExpr.Left))))
                            {
                                resultExprInfo = new RuleBinaryExpressionInfo(lhsType, rhsType, typeof(ulong));
                            }
                            else
                            {
                                error.UserData[RuleUserDataKeys.ErrorObject] = binaryExpr;
                                validation.Errors.Add(error);
                            }
                        }
                        break;

                    case CodeBinaryOperatorType.IdentityEquality:
//.........這裏部分代碼省略.........

        public bool Validate(RuleValidation validation)
        {
            if (validation == null)
                throw new ArgumentNullException("validation");

            // Validate each rule.
            Dictionary<string, object> ruleNames = new Dictionary<string, object>();
            foreach (Rule r in rules)
            {
                if (!string.IsNullOrEmpty(r.Name))  // invalid names caught when validating the rule
                {
                    if (ruleNames.ContainsKey(r.Name))
                    {
                        // Duplicate rule name found.
                        ValidationError error = new ValidationError(Messages.Error_DuplicateRuleName, ErrorNumbers.Error_DuplicateConditions);
                        error.UserData[RuleUserDataKeys.ErrorObject] = r;
                        validation.AddError(error);
                    }
                    else
                    {
                        ruleNames.Add(r.Name, null);
                    }
                }

                r.Validate(validation);
            }

            if (validation.Errors == null || validation.Errors.Count == 0)
                return true;

            return false;
        }

 internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
 {
     Type expressionType = null;
     RuleMethodInvokeExpressionInfo info = null;
     ValidationError item = null;
     BindingFlags @public = BindingFlags.Public;
     CodeMethodInvokeExpression newParent = (CodeMethodInvokeExpression) expression;
     if (isWritten)
     {
         item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeMethodInvokeExpression).ToString() }), 0x17a);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     if ((newParent.Method == null) || (newParent.Method.TargetObject == null))
     {
         item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullMethodTarget, new object[] { newParent.Method.MethodName }), 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     if ((newParent.Method.TypeArguments != null) && (newParent.Method.TypeArguments.Count > 0))
     {
         item = new ValidationError(Messages.GenericMethodsNotSupported, 0x548);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     try
     {
         if (!validation.PushParentExpression(newParent))
         {
             return null;
         }
         RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, newParent.Method.TargetObject, false);
         if (info2 == null)
         {
             return null;
         }
         expressionType = info2.ExpressionType;
         if (expressionType == null)
         {
             return null;
         }
         if (expressionType == typeof(NullLiteral))
         {
             item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullMethodTarget, new object[] { newParent.Method.MethodName }), 0x546);
             item.UserData["ErrorObject"] = newParent;
             validation.Errors.Add(item);
             expressionType = null;
         }
         List<CodeExpression> argumentExprs = new List<CodeExpression>();
         bool flag = false;
         if (newParent.Parameters != null)
         {
             for (int i = 0; i < newParent.Parameters.Count; i++)
             {
                 CodeExpression expression3 = newParent.Parameters[i];
                 if (expression3 == null)
                 {
                     item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullMethodParameter, new object[] { i.ToString(CultureInfo.CurrentCulture), newParent.Method.MethodName }), 0x53d);
                     item.UserData["ErrorObject"] = newParent;
                     validation.Errors.Add(item);
                     expressionType = null;
                 }
                 else
                 {
                     if (expression3 is CodeTypeReferenceExpression)
                     {
                         item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression3.GetType().FullName }), 0x548);
                         item.UserData["ErrorObject"] = expression3;
                         validation.AddError(item);
                         flag = true;
                     }
                     if (RuleExpressionWalker.Validate(validation, expression3, false) == null)
                     {
                         flag = true;
                     }
                     argumentExprs.Add(expression3);
                 }
             }
         }
         if (expressionType == null)
         {
             return null;
         }
         if (flag)
         {
             return null;
         }
         if (newParent.Method.TargetObject is CodeTypeReferenceExpression)
         {
             @public |= BindingFlags.FlattenHierarchy | BindingFlags.Static;
         }
         else
         {
             @public |= BindingFlags.Instance;
         }
         if (validation.AllowInternalMembers(expressionType))
         {
//.........這裏部分代碼省略.........

 internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
 {
     ValidationError item = null;
     Type expressionType = null;
     CodeArrayIndexerExpression newParent = (CodeArrayIndexerExpression) expression;
     CodeExpression targetObject = newParent.TargetObject;
     if (targetObject == null)
     {
         item = new ValidationError(Messages.NullIndexerTarget, 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     if (targetObject is CodeTypeReferenceExpression)
     {
         item = new ValidationError(Messages.IndexersCannotBeStatic, 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     if ((newParent.Indices == null) || (newParent.Indices.Count == 0))
     {
         item = new ValidationError(Messages.MissingIndexExpressions, 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     try
     {
         if (!validation.PushParentExpression(newParent))
         {
             return null;
         }
         RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, newParent.TargetObject, false);
         if (info == null)
         {
             return null;
         }
         expressionType = info.ExpressionType;
         if (expressionType == null)
         {
             return null;
         }
         if (expressionType == typeof(NullLiteral))
         {
             item = new ValidationError(Messages.NullIndexerTarget, 0x53d);
             item.UserData["ErrorObject"] = newParent;
             validation.Errors.Add(item);
             return null;
         }
         if (!expressionType.IsArray)
         {
             item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotIndexType, new object[] { RuleDecompiler.DecompileType(expressionType) }), 0x19b);
             item.UserData["ErrorObject"] = newParent;
             validation.Errors.Add(item);
             return null;
         }
         int arrayRank = expressionType.GetArrayRank();
         if (newParent.Indices.Count != arrayRank)
         {
             item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArrayIndexBadRank, new object[] { arrayRank }), 0x19c);
             item.UserData["ErrorObject"] = newParent;
             validation.Errors.Add(item);
             return null;
         }
         bool flag = false;
         for (int i = 0; i < newParent.Indices.Count; i++)
         {
             CodeExpression expression4 = newParent.Indices[i];
             if (expression4 == null)
             {
                 item = new ValidationError(Messages.NullIndexExpression, 0x53d);
                 item.UserData["ErrorObject"] = newParent;
                 validation.Errors.Add(item);
                 flag = true;
                 continue;
             }
             if (expression4 is CodeDirectionExpression)
             {
                 item = new ValidationError(Messages.IndexerArgCannotBeRefOrOut, 0x19d);
                 item.UserData["ErrorObject"] = expression4;
                 validation.Errors.Add(item);
                 flag = true;
             }
             if (expression4 is CodeTypeReferenceExpression)
             {
                 item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression4.GetType().FullName }), 0x548);
                 item.UserData["ErrorObject"] = expression4;
                 validation.AddError(item);
                 flag = true;
             }
             RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, expression4, false);
             if (info2 != null)
             {
                 Type type = info2.ExpressionType;
                 switch (Type.GetTypeCode(type))
                 {
                     case TypeCode.Char:
                     case TypeCode.SByte:
                     case TypeCode.Byte:
//.........這裏部分代碼省略.........

 public override bool Validate(RuleValidation validator)
 {
     if (validator == null)
     {
         throw new ArgumentNullException("validator");
     }
     bool flag = true;
     if (this.path == null)
     {
         ValidationError error = new ValidationError(Messages.NullUpdate, 0x53d);
         error.UserData["ErrorObject"] = this;
         validator.AddError(error);
         flag = false;
     }
     string[] strArray = this.path.Split(new char[] { '/' });
     if (strArray[0] == "this")
     {
         Type thisType = validator.ThisType;
         for (int i = 1; i < strArray.Length; i++)
         {
             if (strArray[i] == "*")
             {
                 if (i < (strArray.Length - 1))
                 {
                     ValidationError error2 = new ValidationError(Messages.InvalidWildCardInPathQualifier, 0x195);
                     error2.UserData["ErrorObject"] = this;
                     validator.AddError(error2);
                     flag = false;
                 }
                 return flag;
             }
             if (!string.IsNullOrEmpty(strArray[i]) || (i != (strArray.Length - 1)))
             {
                 goto Label_00ED;
             }
             return flag;
         Label_00E6:
             thisType = thisType.GetElementType();
         Label_00ED:
             if (thisType.IsArray)
             {
                 goto Label_00E6;
             }
             BindingFlags bindingAttr = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
             if (validator.AllowInternalMembers(thisType))
             {
                 bindingAttr |= BindingFlags.NonPublic;
             }
             FieldInfo field = thisType.GetField(strArray[i], bindingAttr);
             if (field != null)
             {
                 thisType = field.FieldType;
             }
             else
             {
                 PropertyInfo property = thisType.GetProperty(strArray[i], bindingAttr);
                 if (property != null)
                 {
                     thisType = property.PropertyType;
                 }
                 else
                 {
                     ValidationError error3 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.UpdateUnknownFieldOrProperty, new object[] { strArray[i] }), 0x57b);
                     error3.UserData["ErrorObject"] = this;
                     validator.AddError(error3);
                     return false;
                 }
             }
         }
         return flag;
     }
     ValidationError error4 = new ValidationError(Messages.UpdateNotThis, 0x57b);
     error4.UserData["ErrorObject"] = this;
     validator.AddError(error4);
     return false;
 }

 internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
 {
     RuleExpressionInfo info;
     bool flag;
     CodeDirectionExpression expression2 = (CodeDirectionExpression) expression;
     if (isWritten)
     {
         ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeDirectionExpression).ToString() }), 0x17a);
         item.UserData["ErrorObject"] = expression2;
         validation.Errors.Add(item);
         return null;
     }
     if (expression2.Expression == null)
     {
         ValidationError error2 = new ValidationError(Messages.NullDirectionTarget, 0x53d);
         error2.UserData["ErrorObject"] = expression2;
         validation.Errors.Add(error2);
         return null;
     }
     if (expression2.Expression is CodeTypeReferenceExpression)
     {
         ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression2.Expression.GetType().FullName }), 0x548);
         error.UserData["ErrorObject"] = expression2.Expression;
         validation.AddError(error);
         return null;
     }
     if (expression2.Direction == FieldDirection.Ref)
     {
         flag = true;
         if (RuleExpressionWalker.Validate(validation, expression2.Expression, false) == null)
         {
             return null;
         }
         info = RuleExpressionWalker.Validate(validation, expression2.Expression, true);
     }
     else if (expression2.Direction == FieldDirection.Out)
     {
         flag = true;
         info = RuleExpressionWalker.Validate(validation, expression2.Expression, true);
     }
     else
     {
         flag = false;
         info = RuleExpressionWalker.Validate(validation, expression2.Expression, false);
     }
     if (info == null)
     {
         return null;
     }
     Type expressionType = info.ExpressionType;
     if (expressionType == null)
     {
         return null;
     }
     if (((expressionType != typeof(NullLiteral)) && flag) && !expressionType.IsByRef)
     {
         expressionType = expressionType.MakeByRefType();
     }
     return new RuleExpressionInfo(expressionType);
 }

 internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
 {
     ValidationError item = null;
     RulePropertyExpressionInfo info = null;
     bool nonPublic = false;
     Type expressionType = null;
     CodeIndexerExpression newParent = (CodeIndexerExpression) expression;
     CodeExpression targetObject = newParent.TargetObject;
     if (targetObject == null)
     {
         item = new ValidationError(Messages.NullIndexerTarget, 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     if (targetObject is CodeTypeReferenceExpression)
     {
         item = new ValidationError(Messages.IndexersCannotBeStatic, 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     if ((newParent.Indices == null) || (newParent.Indices.Count == 0))
     {
         item = new ValidationError(Messages.MissingIndexExpressions, 0x53d);
         item.UserData["ErrorObject"] = newParent;
         validation.Errors.Add(item);
         return null;
     }
     try
     {
         if (!validation.PushParentExpression(newParent))
         {
             return null;
         }
         RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, newParent.TargetObject, false);
         if (info2 == null)
         {
             return null;
         }
         expressionType = info2.ExpressionType;
         if (expressionType == null)
         {
             return null;
         }
         if (expressionType == typeof(NullLiteral))
         {
             item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.NullIndexerTarget, new object[0]), 0x53d);
             item.UserData["ErrorObject"] = newParent;
             validation.Errors.Add(item);
             expressionType = null;
         }
         List<CodeExpression> argumentExprs = new List<CodeExpression>();
         bool flag2 = false;
         for (int i = 0; i < newParent.Indices.Count; i++)
         {
             CodeExpression expression4 = newParent.Indices[i];
             if (expression4 == null)
             {
                 item = new ValidationError(Messages.NullIndexExpression, 0x53d);
                 item.UserData["ErrorObject"] = newParent;
                 validation.Errors.Add(item);
                 flag2 = true;
             }
             else
             {
                 CodeDirectionExpression expression5 = expression4 as CodeDirectionExpression;
                 if ((expression5 != null) && (expression5.Direction != FieldDirection.In))
                 {
                     item = new ValidationError(Messages.IndexerArgCannotBeRefOrOut, 0x19d);
                     item.UserData["ErrorObject"] = newParent;
                     validation.Errors.Add(item);
                     flag2 = true;
                 }
                 if (expression4 is CodeTypeReferenceExpression)
                 {
                     item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression4.GetType().FullName }), 0x548);
                     item.UserData["ErrorObject"] = expression4;
                     validation.AddError(item);
                     flag2 = true;
                 }
                 if (RuleExpressionWalker.Validate(validation, expression4, false) == null)
                 {
                     flag2 = true;
                 }
                 else
                 {
                     argumentExprs.Add(expression4);
                 }
             }
         }
         if (expressionType == null)
         {
             return null;
         }
         if (flag2)
         {
             return null;
         }
         BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
//.........這裏部分代碼省略.........

        public override bool Validate(RuleValidation validation)
        {
            if (validation == null)
                throw new ArgumentNullException("validation");

            bool valid = true;

            if (_expression == null)
            {
                valid = false;

                string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionExpressionNull, typeof(CodePrimitiveExpression).ToString());
                ValidationError error = new ValidationError(message, ErrorNumbers.Error_EmptyExpression);
                error.UserData[RuleUserDataKeys.ErrorObject] = this;
                validation.AddError(error);

            }
            else
            {
                valid = validation.ValidateConditionExpression(_expression);
            }

            return valid;
        }

 internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten)
 {
     CodeCastExpression expression2 = (CodeCastExpression) expression;
     if (isWritten)
     {
         ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeCastExpression).ToString() }), 0x17a);
         item.UserData["ErrorObject"] = expression2;
         validation.Errors.Add(item);
         return null;
     }
     if (expression2.Expression == null)
     {
         ValidationError error2 = new ValidationError(Messages.NullCastExpr, 0x53d);
         error2.UserData["ErrorObject"] = expression2;
         validation.Errors.Add(error2);
         return null;
     }
     if (expression2.Expression is CodeTypeReferenceExpression)
     {
         ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, new object[] { expression2.Expression.GetType().FullName }), 0x548);
         error.UserData["ErrorObject"] = expression2.Expression;
         validation.AddError(error);
         return null;
     }
     if (expression2.TargetType == null)
     {
         ValidationError error4 = new ValidationError(Messages.NullCastType, 0x53d);
         error4.UserData["ErrorObject"] = expression2;
         validation.Errors.Add(error4);
         return null;
     }
     RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, expression2.Expression, false);
     if (info == null)
     {
         return null;
     }
     Type expressionType = info.ExpressionType;
     Type type = validation.ResolveType(expression2.TargetType);
     if (type == null)
     {
         return null;
     }
     if (expressionType == typeof(NullLiteral))
     {
         if (ConditionHelper.IsNonNullableValueType(type))
         {
             ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CastOfNullInvalid, new object[] { RuleDecompiler.DecompileType(type) }), 0x53d);
             error5.UserData["ErrorObject"] = expression2;
             validation.Errors.Add(error5);
             return null;
         }
     }
     else
     {
         Type type3 = expressionType;
         if (ConditionHelper.IsNullableValueType(type3))
         {
             type3 = type3.GetGenericArguments()[0];
         }
         Type type4 = type;
         if (ConditionHelper.IsNullableValueType(type4))
         {
             type4 = type4.GetGenericArguments()[0];
         }
         bool flag = false;
         if (type3.IsValueType && type4.IsValueType)
         {
             if (type3.IsEnum)
             {
                 flag = type4.IsEnum || IsNumeric(type4);
             }
             else if (type4.IsEnum)
             {
                 flag = IsNumeric(type3);
             }
             else if (type3 == typeof(char))
             {
                 flag = IsNumeric(type4);
             }
             else if (type4 == typeof(char))
             {
                 flag = IsNumeric(type3);
             }
             else if (type3.IsPrimitive && type4.IsPrimitive)
             {
                 try
                 {
                     Convert.ChangeType(Activator.CreateInstance(type3), type4, CultureInfo.CurrentCulture);
                     flag = true;
                 }
                 catch (Exception)
                 {
                     flag = false;
                 }
             }
         }
         if (!flag)
         {
             ValidationError error6;
             flag = RuleValidation.ExplicitConversionSpecified(expressionType, type, out error6);
//.........這裏部分代碼省略.........