//
// Method extracted from OnRuntimeInitialized
// used on special Evaluation case too.
//
private static RuleDefinitions GetRuleDefinitions(
Activity activity, out CompositeActivity declaringActivity)
{
declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
return(ConditionHelper.Load_Rules_RT(declaringActivity));
}
public static CodeExpression Clone(CodeExpression originalExpression)
{
if (originalExpression == null)
{
return(null);
}
CodeExpression result = GetExpression(originalExpression).Clone(originalExpression);
ConditionHelper.CloneUserData(originalExpression, result);
return(result);
}
internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity)
{
RuleDefinitions rules = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = ConditionHelper.GetRuleDefinitionsFromManifest(declaringActivity.GetType());
if (rules != null)
{
declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
}
return(rules);
}
public static CodeExpression Clone(CodeExpression originalExpression)
{
if (originalExpression == null)
{
return(null);
}
RuleExpressionInternal ruleExpr = GetExpression(originalExpression);
CodeExpression newExpr = ruleExpr.Clone(originalExpression);
ConditionHelper.CloneUserData(originalExpression, newExpr);
return(newExpr);
}
private static CodeMethodReferenceExpression CloneMethodReference(CodeMethodReferenceExpression oldReference)
{
CodeMethodReferenceExpression result = new CodeMethodReferenceExpression {
MethodName = oldReference.MethodName,
TargetObject = RuleExpressionWalker.Clone(oldReference.TargetObject)
};
foreach (CodeTypeReference reference in oldReference.TypeArguments)
{
result.TypeArguments.Add(TypeReferenceExpression.CloneType(reference));
}
ConditionHelper.CloneUserData(oldReference, result);
return(result);
}
internal static CodeTypeReference CloneType(CodeTypeReference oldType)
{
if (oldType == null)
{
return(null);
}
CodeTypeReference result = new CodeTypeReference {
ArrayElementType = CloneType(oldType.ArrayElementType),
ArrayRank = oldType.ArrayRank,
BaseType = oldType.BaseType
};
foreach (CodeTypeReference reference2 in oldType.TypeArguments)
{
result.TypeArguments.Add(CloneType(reference2));
}
ConditionHelper.CloneUserData(oldType, result);
return(result);
}
protected override void InitializeProperties()
{
lock (this.syncLock)
{
if (!this._runtimeInitialized)
{
Activity parentDependencyObject = base.ParentDependencyObject as Activity;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(parentDependencyObject);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(parentDependencyObject) as CompositeActivity;
}
RuleDefinitions definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
if (definitions != null)
{
definitions.OnRuntimeInitialized();
}
base.InitializeProperties();
this._runtimeInitialized = true;
}
}
}
internal static object OnGetRuleConditions(DependencyObject dependencyObject)
{
if (dependencyObject == null)
{
throw new ArgumentNullException("dependencyObject");
}
RuleDefinitions valueBase = dependencyObject.GetValueBase(RuleDefinitionsProperty) as RuleDefinitions;
if (valueBase == null)
{
Activity activity = dependencyObject as Activity;
if (activity.Parent == null)
{
valueBase = ConditionHelper.GetRuleDefinitionsFromManifest(activity.GetType());
if (valueBase != null)
{
dependencyObject.SetValue(RuleDefinitionsProperty, valueBase);
}
}
}
return(valueBase);
}
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);
if (error6 != null)
{
error6.UserData["ErrorObject"] = expression2;
validation.Errors.Add(error6);
return(null);
}
}
if (!flag)
{
ValidationError error7 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CastIncompatibleTypes, new object[] { RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(type) }), 0x53d);
error7.UserData["ErrorObject"] = expression2;
validation.Errors.Add(error7);
return(null);
}
}
return(new RuleExpressionInfo(type));
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
RuleSetReference ruleSetReference = obj as RuleSetReference;
if (ruleSetReference == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, typeof(RuleSetReference).FullName, "obj");
throw new ArgumentException(message, "obj");
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(Activity).Name);
throw new InvalidOperationException(message);
}
PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;
if (validationContext == null)
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(PropertyValidationContext).Name);
throw new InvalidOperationException(message);
}
if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
RuleDefinitions rules = null;
RuleSetCollection ruleSetCollection = null;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
if (activity.Site != null)
{
rules = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
}
else
{
rules = ConditionHelper.Load_Rules_RT(declaringActivity);
}
if (rules != null)
{
ruleSetCollection = rules.RuleSets;
}
if (ruleSetCollection == null || !ruleSetCollection.Contains(ruleSetReference.RuleSetName))
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, ruleSetReference.RuleSetName);
ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_RuleSetNotFound);
validationError.PropertyName = GetFullPropertyName(manager) + "." + "RuleSetName";
validationErrors.Add(validationError);
}
else
{
RuleSet actualRuleSet = ruleSetCollection[ruleSetReference.RuleSetName];
ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
IDisposable localContextScope = (WorkflowCompilationContext.Current == null ? WorkflowCompilationContext.CreateScope(manager) : null);
try
{
RuleValidation validation = new RuleValidation(activity, typeProvider, WorkflowCompilationContext.Current.CheckTypes);
actualRuleSet.Validate(validation);
ValidationErrorCollection actualRuleSetErrors = validation.Errors;
if (actualRuleSetErrors.Count > 0)
{
string expressionPropertyName = GetFullPropertyName(manager);
string genericErrorMsg = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetExpression, expressionPropertyName);
int errorNumber = ErrorNumbers.Error_InvalidRuleSetExpression;
if (activity.Site != null)
{
foreach (ValidationError actualError in actualRuleSetErrors)
{
ValidationError validationError = new ValidationError(actualError.ErrorText, errorNumber);
validationError.PropertyName = expressionPropertyName + "." + "RuleSet Definition";
validationErrors.Add(validationError);
}
}
else
{
foreach (ValidationError actualError in actualRuleSetErrors)
{
ValidationError validationError = new ValidationError(genericErrorMsg + " " + actualError.ErrorText, errorNumber);
validationError.PropertyName = expressionPropertyName;
validationErrors.Add(validationError);
}
}
}
//
}
finally
{
if (localContextScope != null)
{
localContextScope.Dispose();
}
}
}
}
else
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetName, "RuleSetReference");
ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_InvalidRuleSetName);
validationError.PropertyName = GetFullPropertyName(manager) + "." + "RuleSetName";
validationErrors.Add(validationError);
}
return(validationErrors);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (manager.Context == null)
{
throw new InvalidOperationException(Messages.ContextStackMissing);
}
ValidationErrorCollection errors = base.Validate(manager, obj);
RuleConditionReference reference = obj as RuleConditionReference;
if (reference == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, new object[] { typeof(RuleConditionReference).FullName, "obj" }), "obj");
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(Activity).Name }));
}
if (!(manager.Context[typeof(PropertyValidationContext)] is PropertyValidationContext))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(PropertyValidationContext).Name }));
}
if (!string.IsNullOrEmpty(reference.ConditionName))
{
RuleDefinitions definitions = null;
RuleConditionCollection conditions = null;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
if (activity.Site != null)
{
definitions = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
}
else
{
definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
}
if (definitions != null)
{
conditions = definitions.Conditions;
}
if ((conditions == null) || !conditions.Contains(reference.ConditionName))
{
ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ConditionNotFound, new object[] { reference.ConditionName }), 0x53e)
{
PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
};
errors.Add(error);
return(errors);
}
RuleCondition condition = conditions[reference.ConditionName];
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
using ((WorkflowCompilationContext.Current == null) ? WorkflowCompilationContext.CreateScope(manager) : null)
{
RuleValidation validation = new RuleValidation(activity, service, WorkflowCompilationContext.Current.CheckTypes);
condition.Validate(validation);
ValidationErrorCollection errors2 = validation.Errors;
if (errors2.Count > 0)
{
string fullPropertyName = base.GetFullPropertyName(manager);
string errorText = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionExpression, new object[] { fullPropertyName });
int errorNumber = 0x558;
if (activity.Site != null)
{
ValidationError error2 = new ValidationError(errorText, errorNumber)
{
PropertyName = fullPropertyName + ".Expression"
};
errors.Add(error2);
}
else
{
foreach (ValidationError error3 in errors2)
{
ValidationError error4 = new ValidationError(errorText + " " + error3.ErrorText, errorNumber)
{
PropertyName = fullPropertyName + ".Expression"
};
errors.Add(error4);
}
}
}
foreach (RuleCondition condition2 in conditions)
{
if ((condition2.Name == reference.ConditionName) && (condition2 != condition))
{
ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.DuplicateConditions, new object[] { reference.ConditionName }), 0x53f)
{
PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
};
errors.Add(error5);
}
}
return(errors);
}
}
ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionName, new object[] { "ConditionName" }), 0x540)
{
PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
};
errors.Add(item);
return(errors);
}
internal override CodeExpression Clone(CodeExpression expression)
{
CodePrimitiveExpression expression2 = (CodePrimitiveExpression)expression;
return(new CodePrimitiveExpression(ConditionHelper.CloneObject(expression2.Value)));
}
private static bool AdjustValueStandard(Type operandType, object operandValue, Type toType, out object converted)
{
// assume it's the same for now
converted = operandValue;
// check for null
if (operandValue == null)
{
// are we converting to a value type?
if (toType.IsValueType)
{
// is the conversion to nullable?
if (!ConditionHelper.IsNullableValueType(toType))
{
// value type and null, so no conversion possible
string message = string.Format(CultureInfo.CurrentCulture, Messages.CannotCastNullToValueType, RuleDecompiler.DecompileType(toType));
throw new InvalidCastException(message);
}
// here we have a Nullable<T>
// however, we may need to call the implicit conversion operator if the types are not compatible
converted = Activator.CreateInstance(toType);
return(RuleValidation.StandardImplicitConversion(operandType, toType, null, out ValidationError error));
}
// not a value type, so null is valid
return(true);
}
// check simple cases
Type currentType = operandValue.GetType();
if (currentType == toType)
{
return(true);
}
// now the fun begins
// this should handle most class conversions
if (toType.IsAssignableFrom(currentType))
{
return(true);
}
// handle the numerics (both implicit and explicit), along with nullable
// note that if the value was null, it's already handled, so value cannot be nullable
if ((currentType.IsValueType) && (toType.IsValueType))
{
if (currentType.IsEnum)
{
// strip off the enum representation
currentType = Enum.GetUnderlyingType(currentType);
ArithmeticLiteral literal = ArithmeticLiteral.MakeLiteral(currentType, operandValue);
operandValue = literal.Value;
}
bool resultNullable = ConditionHelper.IsNullableValueType(toType);
Type resultType = (resultNullable) ? Nullable.GetUnderlyingType(toType) : toType;
if (resultType.IsEnum)
{
// Enum.ToObject may throw if currentType is not type SByte,
// Int16, Int32, Int64, Byte, UInt16, UInt32, or UInt64.
// So we adjust currentValue to the underlying type (which may throw if out of range)
Type underlyingType = Enum.GetUnderlyingType(resultType);
if (AdjustValueStandard(currentType, operandValue, underlyingType, out object adjusted))
{
converted = Enum.ToObject(resultType, adjusted);
if (resultNullable)
{
converted = Activator.CreateInstance(toType, converted);
}
return(true);
}
}
else if ((resultType.IsPrimitive) || (resultType == typeof(decimal)))
{
// resultType must be a primitive to continue (not a struct)
// (enums and generics handled above)
if (currentType == typeof(char))
{
char c = (char)operandValue;
if (resultType == typeof(float))
{
converted = (float)c;
}
else if (resultType == typeof(double))
{
converted = (double)c;
}
else if (resultType == typeof(decimal))
{
converted = (decimal)c;
}
else
{
converted = ((IConvertible)c).ToType(resultType, CultureInfo.CurrentCulture);
}
if (resultNullable)
{
converted = Activator.CreateInstance(toType, converted);
}
return(true);
}
else if (currentType == typeof(float))
{
float f = (float)operandValue;
if (resultType == typeof(char))
{
converted = (char)f;
}
else
{
converted = ((IConvertible)f).ToType(resultType, CultureInfo.CurrentCulture);
}
if (resultNullable)
{
converted = Activator.CreateInstance(toType, converted);
}
return(true);
}
else if (currentType == typeof(double))
{
double d = (double)operandValue;
if (resultType == typeof(char))
{
converted = (char)d;
}
else
{
converted = ((IConvertible)d).ToType(resultType, CultureInfo.CurrentCulture);
}
if (resultNullable)
{
converted = Activator.CreateInstance(toType, converted);
}
return(true);
}
else if (currentType == typeof(decimal))
{
decimal d = (decimal)operandValue;
if (resultType == typeof(char))
{
converted = (char)d;
}
else
{
converted = ((IConvertible)d).ToType(resultType, CultureInfo.CurrentCulture);
}
if (resultNullable)
{
converted = Activator.CreateInstance(toType, converted);
}
return(true);
}
else
{
if (operandValue is IConvertible convert)
{
try
{
converted = convert.ToType(resultType, CultureInfo.CurrentCulture);
if (resultNullable)
{
converted = Activator.CreateInstance(toType, converted);
}
return(true);
}
catch (InvalidCastException)
{
// not IConvertable, so can't do it
return(false);
}
}
}
}
}
// no luck with standard conversions, so no conversion done
return(false);
}
private static bool AdjustValueStandard(Type operandType, object operandValue, Type toType, out object converted)
{
converted = operandValue;
if (operandValue == null)
{
ValidationError error;
if (!toType.IsValueType)
{
return(true);
}
if (!ConditionHelper.IsNullableValueType(toType))
{
throw new InvalidCastException(string.Format(CultureInfo.CurrentCulture, Messages.CannotCastNullToValueType, new object[] { RuleDecompiler.DecompileType(toType) }));
}
converted = Activator.CreateInstance(toType);
return(RuleValidation.StandardImplicitConversion(operandType, toType, null, out error));
}
Type c = operandValue.GetType();
if (c == toType)
{
return(true);
}
if (toType.IsAssignableFrom(c))
{
return(true);
}
if (c.IsValueType && toType.IsValueType)
{
if (c.IsEnum)
{
c = Enum.GetUnderlyingType(c);
operandValue = ArithmeticLiteral.MakeLiteral(c, operandValue).Value;
}
bool flag = ConditionHelper.IsNullableValueType(toType);
Type enumType = flag ? Nullable.GetUnderlyingType(toType) : toType;
if (enumType.IsEnum)
{
object obj2;
Type underlyingType = Enum.GetUnderlyingType(enumType);
if (AdjustValueStandard(c, operandValue, underlyingType, out obj2))
{
converted = Enum.ToObject(enumType, obj2);
if (flag)
{
converted = Activator.CreateInstance(toType, new object[] { converted });
}
return(true);
}
}
else if (enumType.IsPrimitive || (enumType == typeof(decimal)))
{
if (c == typeof(char))
{
char ch = (char)operandValue;
if (enumType == typeof(float))
{
converted = (float)ch;
}
else if (enumType == typeof(double))
{
converted = (double)ch;
}
else if (enumType == typeof(decimal))
{
converted = ch;
}
else
{
converted = ((IConvertible)ch).ToType(enumType, CultureInfo.CurrentCulture);
}
if (flag)
{
converted = Activator.CreateInstance(toType, new object[] { converted });
}
return(true);
}
if (c == typeof(float))
{
float num = (float)operandValue;
if (enumType == typeof(char))
{
converted = (char)((ushort)num);
}
else
{
converted = ((IConvertible)num).ToType(enumType, CultureInfo.CurrentCulture);
}
if (flag)
{
converted = Activator.CreateInstance(toType, new object[] { converted });
}
return(true);
}
if (c == typeof(double))
{
double num2 = (double)operandValue;
if (enumType == typeof(char))
{
converted = (char)((ushort)num2);
}
else
{
converted = ((IConvertible)num2).ToType(enumType, CultureInfo.CurrentCulture);
}
if (flag)
{
converted = Activator.CreateInstance(toType, new object[] { converted });
}
return(true);
}
if (c == typeof(decimal))
{
decimal num3 = (decimal)operandValue;
if (enumType == typeof(char))
{
converted = (char)num3;
}
else
{
converted = ((IConvertible)num3).ToType(enumType, CultureInfo.CurrentCulture);
}
if (flag)
{
converted = Activator.CreateInstance(toType, new object[] { converted });
}
return(true);
}
IConvertible convertible = operandValue as IConvertible;
if (convertible != null)
{
try
{
converted = convertible.ToType(enumType, CultureInfo.CurrentCulture);
if (flag)
{
converted = Activator.CreateInstance(toType, new object[] { converted });
}
return(true);
}
catch (InvalidCastException)
{
return(false);
}
}
}
}
return(false);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
RuleSetReference reference = obj as RuleSetReference;
if (reference == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, new object[] { typeof(RuleSetReference).FullName, "obj" }), "obj");
}
Activity activity = manager.Context[typeof(Activity)] as Activity;
if (activity == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(Activity).Name }));
}
if (!(manager.Context[typeof(PropertyValidationContext)] is PropertyValidationContext))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(PropertyValidationContext).Name }));
}
if (!string.IsNullOrEmpty(reference.RuleSetName))
{
RuleDefinitions definitions = null;
RuleSetCollection ruleSets = null;
CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
if (activity.Site != null)
{
definitions = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
}
else
{
definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
}
if (definitions != null)
{
ruleSets = definitions.RuleSets;
}
if ((ruleSets == null) || !ruleSets.Contains(reference.RuleSetName))
{
ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, new object[] { reference.RuleSetName }), 0x576)
{
PropertyName = base.GetFullPropertyName(manager) + ".RuleSetName"
};
errors.Add(error);
return(errors);
}
RuleSet set = ruleSets[reference.RuleSetName];
ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
using ((WorkflowCompilationContext.Current == null) ? WorkflowCompilationContext.CreateScope(manager) : null)
{
RuleValidation validation = new RuleValidation(activity, service, WorkflowCompilationContext.Current.CheckTypes);
set.Validate(validation);
ValidationErrorCollection errors2 = validation.Errors;
if (errors2.Count > 0)
{
string fullPropertyName = base.GetFullPropertyName(manager);
string str6 = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetExpression, new object[] { fullPropertyName });
int errorNumber = 0x577;
if (activity.Site != null)
{
foreach (ValidationError error2 in errors2)
{
ValidationError error3 = new ValidationError(error2.ErrorText, errorNumber)
{
PropertyName = fullPropertyName + ".RuleSet Definition"
};
errors.Add(error3);
}
return(errors);
}
foreach (ValidationError error4 in errors2)
{
ValidationError error5 = new ValidationError(str6 + " " + error4.ErrorText, errorNumber)
{
PropertyName = fullPropertyName
};
errors.Add(error5);
}
}
return(errors);
}
}
ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetName, new object[] { "RuleSetReference" }), 0x578)
{
PropertyName = base.GetFullPropertyName(manager) + ".RuleSetName"
};
errors.Add(item);
return(errors);
}
public EnumOperationMethodInfo(Type lhs, CodeBinaryOperatorType operation, Type rhs, bool isZero)
{
this.op = operation;
this.expectedParameters = new ParameterInfo[] { new SimpleParameterInfo(lhs), new SimpleParameterInfo(rhs) };
bool flag = ConditionHelper.IsNullableValueType(lhs);
bool flag2 = ConditionHelper.IsNullableValueType(rhs);
this.lhsBaseType = flag ? Nullable.GetUnderlyingType(lhs) : lhs;
this.rhsBaseType = flag2 ? Nullable.GetUnderlyingType(rhs) : rhs;
if (this.lhsBaseType.IsEnum)
{
this.lhsRootType = EnumHelper.GetUnderlyingType(this.lhsBaseType);
}
else
{
this.lhsRootType = this.lhsBaseType;
}
if (this.rhsBaseType.IsEnum)
{
this.rhsRootType = EnumHelper.GetUnderlyingType(this.rhsBaseType);
}
else
{
this.rhsRootType = this.rhsBaseType;
}
switch (this.op)
{
case CodeBinaryOperatorType.Add:
if (!this.lhsBaseType.IsEnum || !rhs.IsEnum)
{
if (this.lhsBaseType.IsEnum)
{
this.resultBaseType = this.lhsBaseType;
}
else
{
this.resultBaseType = this.rhsBaseType;
}
break;
}
this.resultBaseType = this.lhsRootType;
break;
case CodeBinaryOperatorType.Subtract:
if (!this.rhsBaseType.IsEnum || !this.lhsBaseType.IsEnum)
{
if (this.lhsBaseType.IsEnum)
{
this.resultRootType = this.lhsRootType;
if (isZero && (this.rhsBaseType != this.lhsRootType))
{
this.resultBaseType = this.lhsRootType;
}
else
{
this.resultBaseType = this.lhsBaseType;
}
}
else
{
this.resultRootType = this.rhsRootType;
if (isZero)
{
this.resultBaseType = this.rhsRootType;
}
else
{
this.resultBaseType = this.rhsBaseType;
}
}
}
else
{
this.resultRootType = this.rhsRootType;
this.resultBaseType = this.rhsRootType;
}
this.resultIsNullable = flag || flag2;
this.resultType = this.resultIsNullable ? typeof(Nullable <>).MakeGenericType(new Type[] { this.resultBaseType }) : this.resultBaseType;
return;
case CodeBinaryOperatorType.ValueEquality:
case CodeBinaryOperatorType.LessThan:
case CodeBinaryOperatorType.LessThanOrEqual:
case CodeBinaryOperatorType.GreaterThan:
case CodeBinaryOperatorType.GreaterThanOrEqual:
this.resultType = typeof(bool);
return;
case CodeBinaryOperatorType.BitwiseOr:
case CodeBinaryOperatorType.BitwiseAnd:
case CodeBinaryOperatorType.BooleanOr:
case CodeBinaryOperatorType.BooleanAnd:
return;
default:
return;
}
this.resultIsNullable = flag || flag2;
this.resultType = this.resultIsNullable ? typeof(Nullable <>).MakeGenericType(new Type[] { this.resultBaseType }) : this.resultBaseType;
}
