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)
{
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 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)
{
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 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);
}
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 override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier)
{
string message;
CodeMethodInvokeExpression invokeExpr = (CodeMethodInvokeExpression)expression;
// Get the target object's type.
CodeExpression targetObject = invokeExpr.Method.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 method info from the validation so we can look for [RuleRead] and [RuleWrite] attributes.
RuleMethodInvokeExpressionInfo methodExprInfo = analysis.Validation.ExpressionInfo(invokeExpr) as RuleMethodInvokeExpressionInfo;
if (methodExprInfo == null) // Oops, someone forgot to validate.
{
message = string.Format(CultureInfo.CurrentCulture, Messages.ExpressionNotValidated);
InvalidOperationException exception = new InvalidOperationException(message);
exception.Data[RuleUserDataKeys.ErrorObject] = invokeExpr;
throw exception;
}
MethodInfo mi = methodExprInfo.MethodInfo;
// Look for RuleAttribute's on the invoked method.
List<CodeExpression> attributedExprs = new List<CodeExpression>();
analysis.AnalyzeRuleAttributes(mi, targetObject, qualifier, invokeExpr.Parameters, mi.GetParameters(), attributedExprs);
// See if the target object needs default analysis.
if (!attributedExprs.Contains(targetObject))
{
// No applicable [RuleRead] or [RuleWrite] attributes were found on the target object.
// If we're analyzing for dependencies, assume that this method uses the
// value of the target object, but nothing beneath it.
RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, true, false, null);
}
// See if any of the arguments need default analysis.
for (int i = 0; i < invokeExpr.Parameters.Count; ++i)
{
CodeExpression argExpr = invokeExpr.Parameters[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 override void AnalyzeUsage(CodeExpression expression, RuleAnalysis analysis, bool isRead, bool isWritten, RulePathQualifier qualifier)
{
string message;
CodePropertyReferenceExpression propGetExpr = (CodePropertyReferenceExpression)expression;
// Evaluate the target object and get its type.
CodeExpression targetObject = propGetExpr.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(propGetExpr) 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] = propGetExpr;
throw exception;
}
PropertyInfo pi = propExprInfo.PropertyInfo;
// Look for RuleAttribute's on the invoked property.
List<CodeExpression> attributedExprs = new List<CodeExpression>();
analysis.AnalyzeRuleAttributes(pi, targetObject, qualifier, null, null, attributedExprs);
// See if the target object needs default analysis.
if (!attributedExprs.Contains(targetObject))
{
// The property had no [RuleRead] or [RuleWrite] attributes. Just qualify the target object with
// the property name and proceed with the analysis.
RuleExpressionWalker.AnalyzeUsage(analysis, targetObject, isRead, isWritten, new RulePathQualifier(pi.Name, qualifier));
}
}
