private void AnalyzeInvokeAttribute(RuleAnalysis analysis, Type contextType, Stack<MemberInfo> methodStack, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { foreach (MemberInfo info in contextType.GetMember(this.methodInvoked, MemberTypes.Property | MemberTypes.Method, BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance)) { if (!methodStack.Contains(info)) { methodStack.Push(info); object[] customAttributes = info.GetCustomAttributes(typeof(RuleAttribute), true); if ((customAttributes != null) && (customAttributes.Length != 0)) { foreach (RuleAttribute attribute in (RuleAttribute[]) customAttributes) { RuleReadWriteAttribute attribute2 = attribute as RuleReadWriteAttribute; if (attribute2 != null) { attribute2.Analyze(analysis, info, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } else { ((RuleInvokeAttribute) attribute).AnalyzeInvokeAttribute(analysis, contextType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } } } methodStack.Pop(); } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeDirectionExpression expression2 = (CodeDirectionExpression) expression; CodeExpression expression3 = expression2.Expression; bool flag = false; bool flag2 = true; RulePathQualifier qualifier2 = null; switch (expression2.Direction) { case FieldDirection.In: flag = false; flag2 = true; qualifier2 = new RulePathQualifier("*", null); break; case FieldDirection.Out: flag = true; flag2 = false; qualifier2 = null; break; case FieldDirection.Ref: flag = true; flag2 = true; qualifier2 = analysis.ForWrites ? null : new RulePathQualifier("*", null); break; } RuleExpressionWalker.AnalyzeUsage(analysis, expression3, flag2, flag, qualifier2); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { if (analysis.ForWrites && !isWritten) // If we're tracking writes, then ignore things that aren't written. return; else if (!analysis.ForWrites && !isRead) // ... and vice-versa return; StringBuilder sb = new StringBuilder("this/"); for (RulePathQualifier q = qualifier; q != null; q = q.Next) { sb.Append(q.Name); if (q.Name == "*") { if (q.Next != null) throw new NotSupportedException(Messages.InvalidWildCardInPathQualifier); } else { sb.Append("/"); } } // Add the symbol to our set. analysis.AddSymbol(sb.ToString()); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodePropertyReferenceExpression expression2 = (CodePropertyReferenceExpression) expression; CodeExpression targetObject = expression2.TargetObject; if (analysis.Validation.ExpressionInfo(targetObject) == null) { InvalidOperationException exception = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception.Data["ErrorObject"] = targetObject; throw exception; } RulePropertyExpressionInfo info2 = analysis.Validation.ExpressionInfo(expression2) as RulePropertyExpressionInfo; if (info2 == null) { InvalidOperationException exception2 = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception2.Data["ErrorObject"] = expression2; throw exception2; } PropertyInfo propertyInfo = info2.PropertyInfo; List<CodeExpression> attributedExprs = new List<CodeExpression>(); analysis.AnalyzeRuleAttributes(propertyInfo, targetObject, qualifier, null, null, attributedExprs); if (!attributedExprs.Contains(targetObject)) { RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, new RulePathQualifier(propertyInfo.Name, qualifier)); } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeIndexerExpression expression2 = (CodeIndexerExpression) expression; CodeExpression targetObject = expression2.TargetObject; if (analysis.Validation.ExpressionInfo(targetObject) == null) { InvalidOperationException exception = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception.Data["ErrorObject"] = targetObject; throw exception; } RulePropertyExpressionInfo info2 = analysis.Validation.ExpressionInfo(expression2) as RulePropertyExpressionInfo; if (info2 == null) { InvalidOperationException exception2 = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception2.Data["ErrorObject"] = expression2; throw exception2; } PropertyInfo propertyInfo = info2.PropertyInfo; List<CodeExpression> attributedExprs = new List<CodeExpression>(); analysis.AnalyzeRuleAttributes(propertyInfo, targetObject, qualifier, expression2.Indices, propertyInfo.GetIndexParameters(), attributedExprs); if (!attributedExprs.Contains(targetObject)) { RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, qualifier); } for (int i = 0; i < expression2.Indices.Count; i++) { CodeExpression item = expression2.Indices[i]; if (!attributedExprs.Contains(item)) { RuleExpressionWalker.AnalyzeUsage(analysis, item, true, false, null); } } }
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { if (!analysis.ForWrites) { base.AnalyzeReadWrite(analysis, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } }
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { Stack<MemberInfo> methodStack = new Stack<MemberInfo>(); methodStack.Push(member); this.AnalyzeInvokeAttribute(analysis, member.DeclaringType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); methodStack.Pop(); }
public static void AnalyzeUsage(RuleAnalysis analysis, CodeExpression expression, bool isRead, bool isWritten, RulePathQualifier qualifier) { if (analysis == null) { throw new ArgumentNullException("analysis"); } GetExpression(expression).AnalyzeUsage(expression, analysis, isRead, isWritten, qualifier); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeObjectCreateExpression expression2 = (CodeObjectCreateExpression) expression; foreach (CodeExpression expression3 in expression2.Parameters) { RuleExpressionWalker.AnalyzeUsage(analysis, expression3, true, false, null); } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeArrayIndexerExpression expression2 = (CodeArrayIndexerExpression) expression; RuleExpressionWalker.AnalyzeUsage(analysis, expression2.TargetObject, isRead, isWritten, qualifier); for (int i = 0; i < expression2.Indices.Count; i++) { RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Indices[i], true, false, null); } }
internal void AnalyzeRuleAttributes(MemberInfo member, CodeExpression targetExpr, RulePathQualifier targetQualifier, CodeExpressionCollection argExprs, ParameterInfo[] parameters, List<CodeExpression> attributedExprs) { object[] attrs = member.GetCustomAttributes(typeof(RuleAttribute), true); if (attrs != null && attrs.Length > 0) { RuleAttribute[] ruleAttrs = (RuleAttribute[])attrs; for (int i = 0; i < ruleAttrs.Length; ++i) ruleAttrs[i].Analyze(this, member, targetExpr, targetQualifier, argExprs, parameters, attributedExprs); } }
internal void AnalyzeRuleAttributes(MemberInfo member, CodeExpression targetExpr, RulePathQualifier targetQualifier, CodeExpressionCollection argExprs, ParameterInfo[] parameters, List<CodeExpression> attributedExprs) { object[] customAttributes = member.GetCustomAttributes(typeof(RuleAttribute), true); if ((customAttributes != null) && (customAttributes.Length > 0)) { RuleAttribute[] attributeArray = (RuleAttribute[]) customAttributes; for (int i = 0; i < attributeArray.Length; i++) { attributeArray[i].Analyze(this, member, targetExpr, targetQualifier, argExprs, parameters, attributedExprs); } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeArrayCreateExpression expression2 = (CodeArrayCreateExpression) expression; if (expression2.SizeExpression != null) { RuleExpressionWalker.AnalyzeUsage(analysis, expression2.SizeExpression, true, false, null); } foreach (CodeExpression expression3 in expression2.Initializers) { RuleExpressionWalker.AnalyzeUsage(analysis, expression3, true, false, null); } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeBinaryOperatorExpression expression2 = (CodeBinaryOperatorExpression) expression; RuleBinaryExpressionInfo info = analysis.Validation.ExpressionInfo(expression2) as RuleBinaryExpressionInfo; if (info != null) { MethodInfo methodInfo = info.MethodInfo; if (methodInfo != null) { List<CodeExpression> attributedExprs = new List<CodeExpression>(); CodeExpressionCollection argExprs = new CodeExpressionCollection(); argExprs.Add(expression2.Left); argExprs.Add(expression2.Right); CodeExpression targetExpr = new CodeTypeReferenceExpression(methodInfo.DeclaringType); analysis.AnalyzeRuleAttributes(methodInfo, targetExpr, qualifier, argExprs, methodInfo.GetParameters(), attributedExprs); } } RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Left, true, false, null); RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Right, true, false, null); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { if ((!analysis.ForWrites || isWritten) && (analysis.ForWrites || isRead)) { StringBuilder builder = new StringBuilder("this/"); for (RulePathQualifier qualifier2 = qualifier; qualifier2 != null; qualifier2 = qualifier2.Next) { builder.Append(qualifier2.Name); if (qualifier2.Name == "*") { if (qualifier2.Next != null) { throw new NotSupportedException(Messages.InvalidWildCardInPathQualifier); } } else { builder.Append("/"); } } analysis.AddSymbol(builder.ToString()); } }
private void AnalyzeInvokeAttribute(RuleAnalysis analysis, Type contextType, Stack <MemberInfo> methodStack, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { // 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); for (int m = 0; m < members.Length; ++m) { MemberInfo mi = members[m]; if (!methodStack.Contains(mi)) // Prevent recursion { methodStack.Push(mi); object[] attrs = mi.GetCustomAttributes(typeof(RuleAttribute), true); if (attrs != null && attrs.Length != 0) { RuleAttribute[] ruleAttrs = (RuleAttribute[])attrs; for (int i = 0; i < ruleAttrs.Length; ++i) { RuleAttribute ruleAttr = ruleAttrs[i]; if (ruleAttr is RuleReadWriteAttribute readWriteAttr) { // Just analyze the read/write attribute normally. readWriteAttr.Analyze(analysis, mi, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } else { RuleInvokeAttribute invokeAttr = (RuleInvokeAttribute)ruleAttr; invokeAttr.AnalyzeInvokeAttribute(analysis, contextType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } } } methodStack.Pop(); } } }
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { // A RuleWrite attribute is only applicable if we're analyzing for writes. if (!analysis.ForWrites) { return; } base.AnalyzeReadWrite(analysis, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); }
internal void AnalyzeReadWrite(RuleAnalysis analysis, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { if (string.IsNullOrEmpty(attributePath)) { // If the suffix is null or empty, this means the RuleAttributeTarget has no dependencies. if (attributeTarget == RuleAttributeTarget.This) { // The target object has no dependencies. attributedExpressions.Add(targetExpression); } else if (attributeTarget == RuleAttributeTarget.Parameter) { // ALL arguments have no dependencies. for (int i = 0; i < argumentExpressions.Count; ++i) { attributedExpressions.Add(argumentExpressions[i]); } } } else { string suffix = attributePath; bool isRead = !analysis.ForWrites; bool isWrite = analysis.ForWrites; if (attributeTarget == RuleAttributeTarget.This) { // Target is "This", so perform the analysis on the target expression. // Remove the optional "this/" token if present. string optionalPrefix = "this/"; if (suffix.StartsWith(optionalPrefix, StringComparison.Ordinal)) { suffix = suffix.Substring(optionalPrefix.Length); } RuleExpressionWalker.AnalyzeUsage(analysis, targetExpression, isRead, isWrite, new RulePathQualifier(suffix, targetQualifier)); attributedExpressions.Add(targetExpression); } else if (attributeTarget == RuleAttributeTarget.Parameter) { string paramName = null; int firstSlash = suffix.IndexOf('/'); if (firstSlash >= 0) { paramName = suffix.Substring(0, firstSlash); suffix = suffix.Substring(firstSlash + 1); } else { paramName = suffix; suffix = null; } // Find the ParameterInfo that corresponds to this attribute path. ParameterInfo param = Array.Find <ParameterInfo>(parameters, delegate(ParameterInfo p) { return(p.Name == paramName); }); if (param != null) { RulePathQualifier qualifier = string.IsNullOrEmpty(suffix) ? null : new RulePathQualifier(suffix, null); // 99.9% of the time, the parameter usage attribute only applies to one argument. However, // if this attribute corresponds to the last parameter, then just assume that all the trailing // arguments correspond. (In other words, if the caller passed more arguments then there // are parameters, we assume it was a params array.) // // Usually this loop will only execute once. int end = param.Position + 1; if (param.Position == parameters.Length - 1) { end = argumentExpressions.Count; } for (int i = param.Position; i < end; ++i) { CodeExpression argExpr = argumentExpressions[i]; RuleExpressionWalker.AnalyzeUsage(analysis, argExpr, isRead, isWrite, qualifier); attributedExpressions.Add(argExpr); } } } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeObjectCreateExpression createExpression = (CodeObjectCreateExpression)expression; // check each parameter foreach (CodeExpression p in createExpression.Parameters) { RuleExpressionWalker.AnalyzeUsage(analysis, p, true, false, null); } }
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { // A RuleWrite attribute is only applicable if we're analyzing for writes. if (!analysis.ForWrites) return; base.AnalyzeReadWrite(analysis, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeBinaryOperatorExpression expression2 = (CodeBinaryOperatorExpression)expression; RuleBinaryExpressionInfo info = analysis.Validation.ExpressionInfo(expression2) as RuleBinaryExpressionInfo; if (info != null) { MethodInfo methodInfo = info.MethodInfo; if (methodInfo != null) { List <CodeExpression> attributedExprs = new List <CodeExpression>(); CodeExpressionCollection argExprs = new CodeExpressionCollection(); argExprs.Add(expression2.Left); argExprs.Add(expression2.Right); CodeExpression targetExpr = new CodeTypeReferenceExpression(methodInfo.DeclaringType); analysis.AnalyzeRuleAttributes(methodInfo, targetExpr, qualifier, argExprs, methodInfo.GetParameters(), attributedExprs); } } RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Left, true, false, null); RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Right, true, false, null); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeMethodInvokeExpression expression2 = (CodeMethodInvokeExpression)expression; CodeExpression targetObject = expression2.Method.TargetObject; if (analysis.Validation.ExpressionInfo(targetObject) == null) { InvalidOperationException exception = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception.Data["ErrorObject"] = targetObject; throw exception; } RuleMethodInvokeExpressionInfo info2 = analysis.Validation.ExpressionInfo(expression2) as RuleMethodInvokeExpressionInfo; if (info2 == null) { InvalidOperationException exception2 = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception2.Data["ErrorObject"] = expression2; throw exception2; } MethodInfo methodInfo = info2.MethodInfo; List <CodeExpression> attributedExprs = new List <CodeExpression>(); analysis.AnalyzeRuleAttributes(methodInfo, targetObject, qualifier, expression2.Parameters, methodInfo.GetParameters(), attributedExprs); if (!attributedExprs.Contains(targetObject)) { RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, true, false, null); } for (int i = 0; i < expression2.Parameters.Count; i++) { CodeExpression item = expression2.Parameters[i]; if (!attributedExprs.Contains(item)) { RuleExpressionWalker.AnalyzeUsage(analysis, item, true, false, null); } } }
internal abstract void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier);
internal void AnalyzeReadWrite(RuleAnalysis analysis, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { if (string.IsNullOrEmpty(this.attributePath)) { if (this.attributeTarget == RuleAttributeTarget.This) { attributedExpressions.Add(targetExpression); } else if (this.attributeTarget == RuleAttributeTarget.Parameter) { for (int i = 0; i < argumentExpressions.Count; i++) { attributedExpressions.Add(argumentExpressions[i]); } } } else { string attributePath = this.attributePath; bool isRead = !analysis.ForWrites; bool forWrites = analysis.ForWrites; if (this.attributeTarget == RuleAttributeTarget.This) { string str2 = "this/"; if (attributePath.StartsWith(str2, StringComparison.Ordinal)) { attributePath = attributePath.Substring(str2.Length); } RuleExpressionWalker.AnalyzeUsage(analysis, targetExpression, isRead, forWrites, new RulePathQualifier(attributePath, targetQualifier)); attributedExpressions.Add(targetExpression); } else if (this.attributeTarget == RuleAttributeTarget.Parameter) { string paramName = null; int index = attributePath.IndexOf('/'); if (index >= 0) { paramName = attributePath.Substring(0, index); attributePath = attributePath.Substring(index + 1); } else { paramName = attributePath; attributePath = null; } ParameterInfo info = Array.Find <ParameterInfo>(parameters, p => p.Name == paramName); if (info != null) { RulePathQualifier qualifier = string.IsNullOrEmpty(attributePath) ? null : new RulePathQualifier(attributePath, null); int count = info.Position + 1; if (info.Position == (parameters.Length - 1)) { count = argumentExpressions.Count; } for (int j = info.Position; j < count; j++) { CodeExpression expression = argumentExpressions[j]; RuleExpressionWalker.AnalyzeUsage(analysis, expression, isRead, forWrites, qualifier); attributedExpressions.Add(expression); } } } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodePropertyReferenceExpression expression2 = (CodePropertyReferenceExpression)expression; CodeExpression targetObject = expression2.TargetObject; if (analysis.Validation.ExpressionInfo(targetObject) == null) { InvalidOperationException exception = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception.Data["ErrorObject"] = targetObject; throw exception; } RulePropertyExpressionInfo info2 = analysis.Validation.ExpressionInfo(expression2) as RulePropertyExpressionInfo; if (info2 == null) { InvalidOperationException exception2 = new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated, new object[0])); exception2.Data["ErrorObject"] = expression2; throw exception2; } PropertyInfo propertyInfo = info2.PropertyInfo; List <CodeExpression> attributedExprs = new List <CodeExpression>(); analysis.AnalyzeRuleAttributes(propertyInfo, targetObject, qualifier, null, null, attributedExprs); if (!attributedExprs.Contains(targetObject)) { RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, new RulePathQualifier(propertyInfo.Name, qualifier)); } }
private void AnalyzeInvokeAttribute(RuleAnalysis analysis, Type contextType, Stack <MemberInfo> methodStack, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { foreach (MemberInfo info in contextType.GetMember(this.methodInvoked, MemberTypes.Property | MemberTypes.Method, BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance)) { if (!methodStack.Contains(info)) { methodStack.Push(info); object[] customAttributes = info.GetCustomAttributes(typeof(RuleAttribute), true); if ((customAttributes != null) && (customAttributes.Length != 0)) { foreach (RuleAttribute attribute in (RuleAttribute[])customAttributes) { RuleReadWriteAttribute attribute2 = attribute as RuleReadWriteAttribute; if (attribute2 != null) { attribute2.Analyze(analysis, info, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } else { ((RuleInvokeAttribute)attribute).AnalyzeInvokeAttribute(analysis, contextType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } } } methodStack.Pop(); } } }
private void AnalyzeInvokeAttribute(RuleAnalysis analysis, Type contextType, Stack<MemberInfo> methodStack, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { // 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); for (int m = 0; m < members.Length; ++m) { MemberInfo mi = members[m]; if (!methodStack.Contains(mi)) // Prevent recursion { methodStack.Push(mi); object[] attrs = mi.GetCustomAttributes(typeof(RuleAttribute), true); if (attrs != null && attrs.Length != 0) { RuleAttribute[] ruleAttrs = (RuleAttribute[])attrs; for (int i = 0; i < ruleAttrs.Length; ++i) { RuleAttribute ruleAttr = ruleAttrs[i]; RuleReadWriteAttribute readWriteAttr = ruleAttr as RuleReadWriteAttribute; if (readWriteAttr != null) { // Just analyze the read/write attribute normally. readWriteAttr.Analyze(analysis, mi, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } else { RuleInvokeAttribute invokeAttr = (RuleInvokeAttribute)ruleAttr; invokeAttr.AnalyzeInvokeAttribute(analysis, contextType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } } } methodStack.Pop(); } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { // Analyze the target object, flowing down the qualifier from above. An expression // like: // this.a.b[2,3].c[4].d[5] = 99; // should produce a path similar to: // this/a/b/c/d CodeArrayIndexerExpression arrayIndexerExpr = (CodeArrayIndexerExpression)expression; RuleExpressionWalker.AnalyzeUsage(analysis, arrayIndexerExpr.TargetObject, isRead, isWritten, qualifier); // Analyze the indexer arguments. They are read. for (int i = 0; i < arrayIndexerExpr.Indices.Count; ++i) RuleExpressionWalker.AnalyzeUsage(analysis, arrayIndexerExpr.Indices[i], true, false, null); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { string message; CodeIndexerExpression indexerExpr = (CodeIndexerExpression)expression; // Evaluate the target object and get its type. CodeExpression targetObject = indexerExpr.TargetObject; RuleExpressionInfo targetExprInfo = analysis.Validation.ExpressionInfo(targetObject); if (targetExprInfo == null) // Oops, someone forgot to validate. { message = string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated); InvalidOperationException exception = new InvalidOperationException(message); exception.Data[RuleUserDataKeys.ErrorObject] = targetObject; throw exception; } // Get the property info from the validator so we can look for [RuleRead] and [RuleWrite] attributes. RulePropertyExpressionInfo propExprInfo = analysis.Validation.ExpressionInfo(indexerExpr) as RulePropertyExpressionInfo; if (propExprInfo == null) // Oops, someone forgot to validate. { message = string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated); InvalidOperationException exception = new InvalidOperationException(message); exception.Data[RuleUserDataKeys.ErrorObject] = indexerExpr; throw exception; } PropertyInfo pi = propExprInfo.PropertyInfo; // Look for RuleAttribute's on the invoked indexer property. List<CodeExpression> attributedExprs = new List<CodeExpression>(); analysis.AnalyzeRuleAttributes(pi, targetObject, qualifier, indexerExpr.Indices, pi.GetIndexParameters(), attributedExprs); // See if the target object needs default analysis. if (!attributedExprs.Contains(targetObject)) { // The property had no [RuleRead] or [RuleWrite] attributes. The target object is read or // written (as the case may be). RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, qualifier); } // See if any of the arguments need default analysis. for (int i = 0; i < indexerExpr.Indices.Count; ++i) { CodeExpression argExpr = indexerExpr.Indices[i]; if (!attributedExprs.Contains(argExpr)) { // Similar to the target object, we assume that this method can reads the value // of the parameter, but none of its members. RuleExpressionWalker.AnalyzeUsage(analysis, argExpr, true, false, null); } } }
internal void AnalyzeReadWrite(RuleAnalysis analysis, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { if (string.IsNullOrEmpty(attributePath)) { // If the suffix is null or empty, this means the RuleAttributeTarget has no dependencies. if (attributeTarget == RuleAttributeTarget.This) { // The target object has no dependencies. attributedExpressions.Add(targetExpression); } else if (attributeTarget == RuleAttributeTarget.Parameter) { // ALL arguments have no dependencies. for (int i = 0; i < argumentExpressions.Count; ++i) attributedExpressions.Add(argumentExpressions[i]); } } else { string suffix = attributePath; bool isRead = !analysis.ForWrites; bool isWrite = analysis.ForWrites; if (attributeTarget == RuleAttributeTarget.This) { // Target is "This", so perform the analysis on the target expression. // Remove the optional "this/" token if present. string optionalPrefix = "this/"; if (suffix.StartsWith(optionalPrefix, StringComparison.Ordinal)) suffix = suffix.Substring(optionalPrefix.Length); RuleExpressionWalker.AnalyzeUsage(analysis, targetExpression, isRead, isWrite, new RulePathQualifier(suffix, targetQualifier)); attributedExpressions.Add(targetExpression); } else if (attributeTarget == RuleAttributeTarget.Parameter) { string paramName = null; int firstSlash = suffix.IndexOf('/'); if (firstSlash >= 0) { paramName = suffix.Substring(0, firstSlash); suffix = suffix.Substring(firstSlash + 1); } else { paramName = suffix; suffix = null; } // Find the ParameterInfo that corresponds to this attribute path. ParameterInfo param = Array.Find<ParameterInfo>(parameters, delegate(ParameterInfo p) { return p.Name == paramName; }); if (param != null) { RulePathQualifier qualifier = string.IsNullOrEmpty(suffix) ? null : new RulePathQualifier(suffix, null); // 99.9% of the time, the parameter usage attribute only applies to one argument. However, // if this attribute corresponds to the last parameter, then just assume that all the trailing // arguments correspond. (In other words, if the caller passed more arguments then there // are parameters, we assume it was a params array.) // // Usually this loop will only execute once. int end = param.Position + 1; if (param.Position == parameters.Length - 1) end = argumentExpressions.Count; for (int i = param.Position; i < end; ++i) { CodeExpression argExpr = argumentExpressions[i]; RuleExpressionWalker.AnalyzeUsage(analysis, argExpr, isRead, isWrite, qualifier); attributedExpressions.Add(argExpr); } } } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeArrayIndexerExpression expression2 = (CodeArrayIndexerExpression)expression; RuleExpressionWalker.AnalyzeUsage(analysis, expression2.TargetObject, isRead, isWritten, qualifier); for (int i = 0; i < expression2.Indices.Count; i++) { RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Indices[i], true, false, null); } }
internal void AnalyzeReadWrite(RuleAnalysis analysis, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions) { if (string.IsNullOrEmpty(this.attributePath)) { if (this.attributeTarget == RuleAttributeTarget.This) { attributedExpressions.Add(targetExpression); } else if (this.attributeTarget == RuleAttributeTarget.Parameter) { for (int i = 0; i < argumentExpressions.Count; i++) { attributedExpressions.Add(argumentExpressions[i]); } } } else { string attributePath = this.attributePath; bool isRead = !analysis.ForWrites; bool forWrites = analysis.ForWrites; if (this.attributeTarget == RuleAttributeTarget.This) { string str2 = "this/"; if (attributePath.StartsWith(str2, StringComparison.Ordinal)) { attributePath = attributePath.Substring(str2.Length); } RuleExpressionWalker.AnalyzeUsage(analysis, targetExpression, isRead, forWrites, new RulePathQualifier(attributePath, targetQualifier)); attributedExpressions.Add(targetExpression); } else if (this.attributeTarget == RuleAttributeTarget.Parameter) { string paramName = null; int index = attributePath.IndexOf('/'); if (index >= 0) { paramName = attributePath.Substring(0, index); attributePath = attributePath.Substring(index + 1); } else { paramName = attributePath; attributePath = null; } ParameterInfo info = Array.Find<ParameterInfo>(parameters, p => p.Name == paramName); if (info != null) { RulePathQualifier qualifier = string.IsNullOrEmpty(attributePath) ? null : new RulePathQualifier(attributePath, null); int count = info.Position + 1; if (info.Position == (parameters.Length - 1)) { count = argumentExpressions.Count; } for (int j = info.Position; j < count; j++) { CodeExpression expression = argumentExpressions[j]; RuleExpressionWalker.AnalyzeUsage(analysis, expression, isRead, forWrites, qualifier); attributedExpressions.Add(expression); } } } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeArrayCreateExpression createExpression = (CodeArrayCreateExpression)expression; if (createExpression.SizeExpression != null) RuleExpressionWalker.AnalyzeUsage(analysis, createExpression.SizeExpression, true, false, null); foreach (CodeExpression p in createExpression.Initializers) RuleExpressionWalker.AnalyzeUsage(analysis, p, true, false, null); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeObjectCreateExpression expression2 = (CodeObjectCreateExpression)expression; foreach (CodeExpression expression3 in expression2.Parameters) { RuleExpressionWalker.AnalyzeUsage(analysis, expression3, true, false, null); } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeDirectionExpression expression2 = (CodeDirectionExpression)expression; CodeExpression expression3 = expression2.Expression; bool flag = false; bool flag2 = true; RulePathQualifier qualifier2 = null; switch (expression2.Direction) { case FieldDirection.In: flag = false; flag2 = true; qualifier2 = new RulePathQualifier("*", null); break; case FieldDirection.Out: flag = true; flag2 = false; qualifier2 = null; break; case FieldDirection.Ref: flag = true; flag2 = true; qualifier2 = analysis.ForWrites ? null : new RulePathQualifier("*", null); break; } RuleExpressionWalker.AnalyzeUsage(analysis, expression3, flag2, flag, qualifier2); }
public RulePathQualifier(string name, RulePathQualifier next) { this.name = name; this.next = next; }
internal abstract void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions);
internal void AnalyzeRuleAttributes(MemberInfo member, CodeExpression targetExpr, RulePathQualifier targetQualifier, CodeExpressionCollection argExprs, ParameterInfo[] parameters, List <CodeExpression> attributedExprs) { object[] attrs = member.GetCustomAttributes(typeof(RuleAttribute), true); if (attrs != null && attrs.Length > 0) { RuleAttribute[] ruleAttrs = (RuleAttribute[])attrs; for (int i = 0; i < ruleAttrs.Length; ++i) { ruleAttrs[i].Analyze(this, member, targetExpr, targetQualifier, argExprs, parameters, attributedExprs); } } }
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { Stack <MemberInfo> methodStack = new Stack <MemberInfo>(); methodStack.Push(member); AnalyzeInvokeAttribute(analysis, member.DeclaringType, methodStack, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); methodStack.Pop(); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { if ((!analysis.ForWrites || isWritten) && (analysis.ForWrites || isRead)) { StringBuilder builder = new StringBuilder("this/"); for (RulePathQualifier qualifier2 = qualifier; qualifier2 != null; qualifier2 = qualifier2.Next) { builder.Append(qualifier2.Name); if (qualifier2.Name == "*") { if (qualifier2.Next != null) { throw new NotSupportedException(Messages.InvalidWildCardInPathQualifier); } } else { builder.Append("/"); } } analysis.AddSymbol(builder.ToString()); } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeArrayCreateExpression expression2 = (CodeArrayCreateExpression)expression; if (expression2.SizeExpression != null) { RuleExpressionWalker.AnalyzeUsage(analysis, expression2.SizeExpression, true, false, null); } foreach (CodeExpression expression3 in expression2.Initializers) { RuleExpressionWalker.AnalyzeUsage(analysis, expression3, true, false, null); } }
internal override void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List <CodeExpression> attributedExpressions) { if (analysis.ForWrites) { base.AnalyzeReadWrite(analysis, targetExpression, targetQualifier, argumentExpressions, parameters, attributedExpressions); } }
public RulePathQualifier(string name, RulePathQualifier next) { this.name = name; this.next = next; }
internal void AnalyzeRuleAttributes(MemberInfo member, CodeExpression targetExpr, RulePathQualifier targetQualifier, CodeExpressionCollection argExprs, ParameterInfo[] parameters, List <CodeExpression> attributedExprs) { object[] customAttributes = member.GetCustomAttributes(typeof(RuleAttribute), true); if ((customAttributes != null) && (customAttributes.Length > 0)) { RuleAttribute[] attributeArray = (RuleAttribute[])customAttributes; for (int i = 0; i < attributeArray.Length; i++) { attributeArray[i].Analyze(this, member, targetExpr, targetQualifier, argExprs, parameters, attributedExprs); } } }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeCastExpression expression2 = (CodeCastExpression) expression; RuleExpressionWalker.AnalyzeUsage(analysis, expression2.Expression, true, false, null); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { ruleExpr.AnalyzeUsage(analysis, isRead, isWritten, qualifier); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { this.ruleExpr.AnalyzeUsage(analysis, isRead, isWritten, qualifier); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeBinaryOperatorExpression binaryExpr = (CodeBinaryOperatorExpression)expression; // Get the method info from the validation so we can look for [RuleRead] and [RuleWrite] attributes. RuleBinaryExpressionInfo expressionInfo = analysis.Validation.ExpressionInfo(binaryExpr) as RuleBinaryExpressionInfo; if (expressionInfo != null) { // we may be calling a method, not a default operator MethodInfo method = expressionInfo.MethodInfo; if (method != null) { List<CodeExpression> attributedExprs = new List<CodeExpression>(); CodeExpressionCollection arguments = new CodeExpressionCollection(); arguments.Add(binaryExpr.Left); arguments.Add(binaryExpr.Right); CodeExpression targetObject = new CodeTypeReferenceExpression(method.DeclaringType); analysis.AnalyzeRuleAttributes(method, targetObject, qualifier, arguments, method.GetParameters(), attributedExprs); } } // Analyze the left & right children. RuleExpressionWalker.AnalyzeUsage(analysis, binaryExpr.Left, true, false, null); RuleExpressionWalker.AnalyzeUsage(analysis, binaryExpr.Right, true, false, null); }
public static void AnalyzeUsage(RuleAnalysis analysis, CodeExpression expression, bool isRead, bool isWritten, RulePathQualifier qualifier) { if (analysis == null) { throw new ArgumentNullException("analysis"); } GetExpression(expression).AnalyzeUsage(expression, analysis, isRead, isWritten, qualifier); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeFieldReferenceExpression expression2 = (CodeFieldReferenceExpression)expression; CodeExpression targetObject = expression2.TargetObject; RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, new RulePathQualifier(expression2.FieldName, qualifier)); }
internal override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier) { CodeFieldReferenceExpression expression2 = (CodeFieldReferenceExpression) expression; CodeExpression targetObject = expression2.TargetObject; RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, new RulePathQualifier(expression2.FieldName, qualifier)); }
internal abstract void Analyze(RuleAnalysis analysis, MemberInfo member, CodeExpression targetExpression, RulePathQualifier targetQualifier, CodeExpressionCollection argumentExpressions, ParameterInfo[] parameters, List<CodeExpression> attributedExpressions);