private static bool Compare(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null && rightOperand != null)
rightOperand = TypeConverterHelper.Convert(rightOperand.ToString(), leftOperand.GetType().FullName);
var leftOperand1 = leftOperand as IComparable;
var rightOperand1 = rightOperand as IComparable;
if (leftOperand1 != null && rightOperand1 != null)
return EvaluateComparable(leftOperand1, operatorType, rightOperand1);
switch (operatorType)
{
case ComparisonConditionType.Equal:
return Equals(leftOperand, rightOperand);
case ComparisonConditionType.NotEqual:
return !Equals(leftOperand, rightOperand);
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if (leftOperand1 == null && rightOperand1 == null)
throw new ArgumentException("Invalid operands.");
if (leftOperand1 == null)
throw new ArgumentException("Invalid left operand.");
throw new ArgumentException("Invalid right operand.");
default:
return false;
}
}
/// <summary>
/// Mit dieser Methode werden Operanden ausgewertet.
///
/// </summary>
/// <param name="leftOperand">Linker Operand aus der "LeftOperand"-Eigenschaft.</param><param name="operatorType">Operator aus "Operator"-Eigenschaft.</param><param name="rightOperand">Rechter Operand aus der "RightOperand"-Eigenschaft.</param>
/// <returns>
/// Gibt "true" zurück, wenn die Bedingung erfüllt ist, gibt andernfalls "false" zurück.
/// </returns>
internal static bool EvaluateImpl(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
var flag = false;
if (leftOperand != null)
{
var type = leftOperand.GetType();
if (rightOperand != null)
{
rightOperand = TypeConverterHelper.DoConversionFrom(TypeConverterHelper.GetTypeConverter(type), rightOperand);
}
}
var leftOperand1 = leftOperand as IComparable;
var rightOperand1 = rightOperand as IComparable;
if (leftOperand1 != null && rightOperand1 != null)
{
return(EvaluateComparable(leftOperand1, operatorType, rightOperand1));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
flag = Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.NotEqual:
flag = !Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if (leftOperand1 == null && rightOperand1 == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "LeftOperand of type {1} and RightOperand of type {0} cannot be used with operator {2}."
, leftOperand != null ? (object)leftOperand.GetType().Name : (object)"null"
, rightOperand != null ? (object)rightOperand.GetType().Name : (object)"null"
, (object)((object)operatorType).ToString()));
}
else if (leftOperand1 == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "LeftOperand of type {0} cannot be used with operator {1}.", new object[]
{
leftOperand != null ? leftOperand.GetType().Name : "null",
((object)operatorType).ToString()
}));
}
else
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "RightOperand of type {0} cannot be used with operator {1}.", new object[]
{
rightOperand != null ? rightOperand.GetType().Name : "null",
((object)operatorType).ToString()
}));
}
}
return(flag);
}
private static bool Compare(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null && rightOperand != null)
{
rightOperand = TypeConverterHelper.Convert(rightOperand.ToString(), leftOperand.GetType().FullName);
}
IComparable leftComparableOperand = leftOperand as IComparable;
IComparable rightComparableOperand = rightOperand as IComparable;
if ((leftComparableOperand != null) && (rightComparableOperand != null))
{
return(DataTriggerBehavior.EvaluateComparable(leftComparableOperand, operatorType, rightComparableOperand));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return(object.Equals(leftOperand, rightOperand));
case ComparisonConditionType.NotEqual:
return(!object.Equals(leftOperand, rightOperand));
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
{
if (leftComparableOperand == null && rightComparableOperand == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ResourceHelper.InvalidOperands,
leftOperand != null ? leftOperand.GetType().Name : "null",
rightOperand != null ? rightOperand.GetType().Name : "null",
operatorType.ToString()));
}
else if (leftComparableOperand == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ResourceHelper.InvalidLeftOperand,
leftOperand != null ? leftOperand.GetType().Name : "null",
operatorType.ToString()));
}
else
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ResourceHelper.InvalidRightOperand,
rightOperand != null ? rightOperand.GetType().Name : "null",
operatorType.ToString()));
}
}
}
return(false);
}
private static bool EvaluateComparable(ComparisonConditionType comparisonType, IComparable leftOperand, IComparable rightOperand)
{
object right;
try
{
right = Convert.ChangeType(rightOperand, leftOperand.GetType(), CultureInfo.CurrentCulture);
}
catch (Exception)
{
return(false);
}
if (null == right)
{
return(ComparisonConditionType.NotEqual == comparisonType);
}
var op = leftOperand.CompareTo(right);
switch (comparisonType)
{
case ComparisonConditionType.Equal:
{
return(0 == op);
}
case ComparisonConditionType.NotEqual:
{
return(0 != op);
}
case ComparisonConditionType.LessThan:
{
return(0 > op);
}
case ComparisonConditionType.LessThanOrEqual:
{
return(0 >= op);
}
case ComparisonConditionType.GreaterThan:
{
return(0 < op);
}
case ComparisonConditionType.GreaterThanOrEqual:
{
return(0 <= op);
}
default:
{
return(false);
}
}
}
private static DataTrigger CreateDataTrigger(object bindingValue, ComparisonConditionType comparisonType, object valueValue)
{
return(new DataTrigger()
{
Binding = bindingValue,
Comparison = comparisonType,
Value = valueValue,
});
}
/// <summary>
///
/// </summary>
/// <param name="comparisonType"></param>
/// <param name="leftOperand"></param>
/// <param name="rightOperand"></param>
/// <returns></returns>
internal static bool Evaluate(ComparisonConditionType comparisonType, object leftOperand, object rightOperand)
{
if (null != leftOperand)
{
var expected = leftOperand.GetType();
if (null != rightOperand)
{
if (expected.GetTypeInfo().IsEnum&& Enum.IsDefined(expected, rightOperand))
{
rightOperand = Enum.ToObject(expected, rightOperand);
}
}
}
var left = leftOperand as IComparable;
var right = rightOperand as IComparable;
if (null != left && null != right)
{
return(EvaluateComparable(comparisonType, left, right));
}
switch (comparisonType)
{
case ComparisonConditionType.Equal:
{
return(Object.Equals(left, right));
}
case ComparisonConditionType.NotEqual:
{
return(false == Object.Equals(left, right));
}
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
{
if (null == left && null == right)
{
throw new ArgumentException();
}
if (null == left)
{
throw new ArgumentException();
}
throw new ArgumentException();
}
}
return(false);
}
/// <summary>
/// This method evaluates operands.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
internal static bool EvaluateImpl(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
bool result = false;
if (leftOperand != null)
{
Type leftType = leftOperand.GetType();
if (rightOperand != null)
{
TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(leftType);
rightOperand = TypeConverterHelper.DoConversionFrom(typeConverter, rightOperand);
}
}
IComparable leftComparableOperand = leftOperand as IComparable;
IComparable rightComparableOperand = rightOperand as IComparable;
// If both operands are comparable, use arithmetic comparison
if (leftComparableOperand != null && rightComparableOperand != null)
{
return(ComparisonLogic.EvaluateComparable(leftComparableOperand, operatorType, rightComparableOperand));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
result = object.Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.NotEqual:
result = !object.Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
if (leftComparableOperand == null && rightComparableOperand == null)
{
throw new ArgumentException();
}
else if (leftComparableOperand == null)
{
throw new ArgumentException();
}
else
{
throw new ArgumentException();
}
}
return(result);
}
private bool UpdateComparison()
{
ComparisonConditionType comparison = Comparison;
if (_comparison != comparison)
{
_comparison = comparison;
return(true);
}
return(false);
}
/// <summary>
/// Evaluates both operands that implement the IComparable interface.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
private static bool EvaluateComparable(IComparable leftOperand, ComparisonConditionType operatorType, IComparable rightOperand)
{
object convertedOperand = null;
try
{
convertedOperand = Convert.ChangeType(rightOperand, leftOperand.GetType(), CultureInfo.CurrentCulture);
}
catch (FormatException)
{
// FormatException: Convert.ChangeType("hello", typeof(double), ...);
}
catch (InvalidCastException)
{
// InvalidCastException: Convert.ChangeType(4.0d, typeof(Rectangle), ...);
}
if (convertedOperand == null)
{
return(operatorType == ComparisonConditionType.NotEqual);
}
int comparison = leftOperand.CompareTo((IComparable)convertedOperand);
bool result = false;
switch (operatorType)
{
case ComparisonConditionType.Equal:
result = comparison == 0;
break;
case ComparisonConditionType.GreaterThan:
result = comparison > 0;
break;
case ComparisonConditionType.GreaterThanOrEqual:
result = comparison >= 0;
break;
case ComparisonConditionType.LessThan:
result = comparison < 0;
break;
case ComparisonConditionType.LessThanOrEqual:
result = comparison <= 0;
break;
case ComparisonConditionType.NotEqual:
result = comparison != 0;
break;
}
return(result);
}
private static bool Compare(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null && rightOperand != null)
{
rightOperand = TypeConverterHelper.Convert(rightOperand.ToString(), leftOperand.GetType().FullName);
}
IComparable comparable = leftOperand as IComparable;
IComparable comparable2 = rightOperand as IComparable;
if (comparable != null && comparable2 != null)
{
return(DataTriggerBehavior.EvaluateComparable(comparable, operatorType, comparable2));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return(object.Equals(leftOperand, rightOperand));
case ComparisonConditionType.NotEqual:
return(!object.Equals(leftOperand, rightOperand));
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if (comparable == null && comparable2 == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "InvalidOperands", new object[]
{
(leftOperand != null) ? leftOperand.GetType().Name : "null",
(rightOperand != null) ? rightOperand.GetType().Name : "null",
operatorType.ToString()
}));
}
if (comparable == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "InvalidLeftOperand", new object[]
{
(leftOperand != null) ? leftOperand.GetType().Name : "null",
operatorType.ToString()
}));
}
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "InvalidRightOperand", new object[]
{
(rightOperand != null) ? rightOperand.GetType().Name : "null",
operatorType.ToString()
}));
default:
return(false);
}
}
/// <summary>
/// This method evaluates operands.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
internal static bool EvaluateImpl(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
bool result = false;
if (leftOperand != null)
{
Type type = leftOperand.GetType();
if (rightOperand != null)
{
var typeConverter = TypeConverterHelper.GetTypeConverter(type);
rightOperand = TypeConverterHelper.DoConversionFrom(typeConverter, rightOperand);
}
}
IComparable leftOperandComparable = leftOperand as IComparable;
IComparable rightOperandComparable = rightOperand as IComparable;
if (leftOperandComparable != null && rightOperandComparable != null)
{
return(EvaluateComparable(leftOperandComparable, operatorType, rightOperandComparable));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
result = object.Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.NotEqual:
result = !object.Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if (leftOperandComparable == null && rightOperandComparable == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "LeftOperand of type '{1}' and RightOperand of type '{0}' cannot be used with operator '{2}'.", (leftOperand != null) ? leftOperand.GetType().Name : "null", (rightOperand != null) ? rightOperand.GetType().Name : "null", operatorType.ToString()));
}
if (leftOperandComparable == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "LeftOperand of type '{0}' cannot be used with operator '{1}'.", (leftOperand != null) ? leftOperand.GetType().Name : "null", operatorType.ToString()));
}
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "RightOperand of type '{0}' cannot be used with operator '{1}'.", (rightOperand != null) ? rightOperand.GetType().Name : "null", operatorType.ToString()));
}
return(result);
}
/// <summary>
/// Evaluates both operands that implement the IComparable interface.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
private static bool EvaluateComparable(IComparable leftOperand, ComparisonConditionType operatorType, IComparable rightOperand)
{
object obj = null;
try
{
obj = Convert.ChangeType(rightOperand, leftOperand.GetType(), CultureInfo.CurrentCulture);
}
catch (FormatException)
{
}
catch (InvalidCastException)
{
}
if (obj == null)
{
return(operatorType == ComparisonConditionType.NotEqual);
}
int num = leftOperand.CompareTo((IComparable)obj);
bool result = false;
switch (operatorType)
{
case ComparisonConditionType.Equal:
result = num == 0;
break;
case ComparisonConditionType.GreaterThan:
result = num > 0;
break;
case ComparisonConditionType.GreaterThanOrEqual:
result = num >= 0;
break;
case ComparisonConditionType.LessThan:
result = num < 0;
break;
case ComparisonConditionType.LessThanOrEqual:
result = num <= 0;
break;
case ComparisonConditionType.NotEqual:
result = num != 0;
break;
}
return(result);
}
/// <summary>
/// Method to compare two objects
/// </summary>
/// <param name="leftOperand"></param>
/// <param name="operatorType"></param>
/// <param name="rightOperand"></param>
/// <returns></returns>
internal static bool Evaluate(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null)
{
if (rightOperand != null)
{
object newValue = TypeConverter.Convert(leftOperand.GetType(), rightOperand);
if (newValue != null)
{
rightOperand = newValue;
}
}
}
IComparable comparable = leftOperand as IComparable;
IComparable comparable2 = rightOperand as IComparable;
if ((comparable != null) && (comparable2 != null))
{
return(EvaluateComparable(comparable, operatorType, comparable2));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return(Equals(leftOperand, rightOperand));
case ComparisonConditionType.NotEqual:
return(!Equals(leftOperand, rightOperand));
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if ((comparable == null) && (comparable2 == null))
{
throw new ArgumentException("Operands must implement IComparable");
}
if (comparable == null)
{
throw new ArgumentException("Invalid left operand - must implement IComparable");
}
throw new ArgumentException("Invalid right operand - must implement IComparable.");
}
return(false);
}
/// <summary>
/// This method evaluates operands.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
internal static bool EvaluateImpl(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null)
{
Type type = leftOperand.GetType();
if (rightOperand != null)
{
//rightOperand = TypeConverterHelper.DoConversionFrom(TypeConverterHelper.GetTypeConverter(type), rightOperand);
if (type.GetTypeInfo().IsEnum && Enum.IsDefined(type, rightOperand))
rightOperand = Enum.ToObject(type, rightOperand);
}
}
IComparable comparable = leftOperand as IComparable;
IComparable comparable2 = rightOperand as IComparable;
if ((comparable != null) && (comparable2 != null))
{
return EvaluateComparable(comparable, operatorType, comparable2);
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return object.Equals(leftOperand, rightOperand);
case ComparisonConditionType.NotEqual:
return !object.Equals(leftOperand, rightOperand);
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if ((comparable == null) && (comparable2 == null))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, ExceptionStringTableHelper.InvalidOperands, new object[] { (leftOperand != null) ? leftOperand.GetType().Name : "null", (rightOperand != null) ? rightOperand.GetType().Name : "null", operatorType.ToString() }));
}
if (comparable == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, ExceptionStringTableHelper.InvalidLeftOperand, new object[] { (leftOperand != null) ? leftOperand.GetType().Name : "null", operatorType.ToString() }));
}
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, ExceptionStringTableHelper.InvalidRightOperand, new object[] { (rightOperand != null) ? rightOperand.GetType().Name : "null", operatorType.ToString() }));
}
return false;
}
private static bool Compare(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null && rightOperand != null)
{
rightOperand = TypeConverterHelper.Convert(rightOperand.ToString(), leftOperand.GetType().FullName);
}
var leftOperand1 = leftOperand as IComparable;
var rightOperand1 = rightOperand as IComparable;
if (leftOperand1 != null && rightOperand1 != null)
{
return(EvaluateComparable(leftOperand1, operatorType, rightOperand1));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return(Equals(leftOperand, rightOperand));
case ComparisonConditionType.NotEqual:
return(!Equals(leftOperand, rightOperand));
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if (leftOperand1 == null && rightOperand1 == null)
{
throw new ArgumentException("Invalid operands.");
}
if (leftOperand1 == null)
{
throw new ArgumentException("Invalid left operand.");
}
throw new ArgumentException("Invalid right operand.");
default:
return(false);
}
}
/// <summary>
/// Method to compare two operands using IComparable
/// </summary>
/// <param name="leftOperand"></param>
/// <param name="operatorType"></param>
/// <param name="rightOperand"></param>
/// <returns></returns>
private static bool EvaluateComparable(IComparable leftOperand, ComparisonConditionType operatorType, IComparable rightOperand)
{
object value = null;
try
{
value = Convert.ChangeType(rightOperand, leftOperand.GetType());
}
catch (Exception)
{
}
if (value == null)
{
return(operatorType == ComparisonConditionType.NotEqual);
}
int num = leftOperand.CompareTo(value);
switch (operatorType)
{
case ComparisonConditionType.Equal:
return(num == 0);
case ComparisonConditionType.NotEqual:
return(num != 0);
case ComparisonConditionType.LessThan:
return(num < 0);
case ComparisonConditionType.LessThanOrEqual:
return(num <= 0);
case ComparisonConditionType.GreaterThan:
return(num > 0);
case ComparisonConditionType.GreaterThanOrEqual:
return(num >= 0);
}
return(false);
}
/// <summary>
/// Evaluates both operands that implement the IComparable interface.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
private static bool EvaluateComparable(IComparable leftOperand, ComparisonConditionType operatorType, IComparable rightOperand)
{
object obj2 = null;
try
{
obj2 = Convert.ChangeType(rightOperand, leftOperand.GetType(), CultureInfo.CurrentCulture);
}
catch (FormatException)
{
}
catch (InvalidCastException)
{
}
if (obj2 == null)
{
return (operatorType == ComparisonConditionType.NotEqual);
}
int num = leftOperand.CompareTo((IComparable)obj2);
switch (operatorType)
{
case ComparisonConditionType.Equal:
return (num == 0);
case ComparisonConditionType.NotEqual:
return (num != 0);
case ComparisonConditionType.LessThan:
return (num < 0);
case ComparisonConditionType.LessThanOrEqual:
return (num <= 0);
case ComparisonConditionType.GreaterThan:
return (num > 0);
case ComparisonConditionType.GreaterThanOrEqual:
return (num >= 0);
}
return false;
}
public static bool Evaluate(object left, ComparisonConditionType comparison, object right)
{
if (comparison == ComparisonConditionType.Equal)
{
return(object.Equals(left, right));
}
else if (comparison == ComparisonConditionType.NotEqual)
{
return(!object.Equals(left, right));
}
else
{
IComparable leftComparable = left as IComparable;
IComparable rightComparable = right as IComparable;
if (leftComparable == null || rightComparable == null)
{
return(false);
}
switch (comparison)
{
case ComparisonConditionType.LessThan:
return(leftComparable.CompareTo(rightComparable) < 0);
case ComparisonConditionType.LessThanOrEqual:
return(leftComparable.CompareTo(rightComparable) <= 0);
case ComparisonConditionType.GreaterThan:
return(leftComparable.CompareTo(rightComparable) > 0);
case ComparisonConditionType.GreaterThanOrEqual:
return(leftComparable.CompareTo(rightComparable) >= 0);
}
}
return(false);
}
private static bool Compare(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null && rightOperand != null)
{
rightOperand = TypeConverterHelper.Convert(rightOperand.ToString(), leftOperand.GetType().FullName);
}
IComparable leftComparableOperand = leftOperand as IComparable;
IComparable rightComparableOperand = rightOperand as IComparable;
if ((leftComparableOperand != null) && (rightComparableOperand != null))
{
return DataTriggerBehavior.EvaluateComparable(leftComparableOperand, operatorType, rightComparableOperand);
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return object.Equals(leftOperand, rightOperand);
case ComparisonConditionType.NotEqual:
return !object.Equals(leftOperand, rightOperand);
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
{
if (leftComparableOperand == null && rightComparableOperand == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ResourceHelper.InvalidOperands,
leftOperand != null ? leftOperand.GetType().Name : "null",
rightOperand != null ? rightOperand.GetType().Name : "null",
operatorType.ToString()));
}
else if (leftComparableOperand == null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ResourceHelper.InvalidLeftOperand,
leftOperand != null ? leftOperand.GetType().Name : "null",
operatorType.ToString()));
}
else
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ResourceHelper.InvalidRightOperand,
rightOperand != null ? rightOperand.GetType().Name : "null",
operatorType.ToString()));
}
}
}
return false;
}
/// <summary>
/// Evaluates both operands that implement the IComparable interface.
/// </summary>
private static bool EvaluateComparable(IComparable leftOperand, ComparisonConditionType operatorType, IComparable rightOperand)
{
object convertedOperand = null;
try
{
convertedOperand = Convert.ChangeType(rightOperand, leftOperand.GetType(), CultureInfo.CurrentCulture);
}
catch (FormatException)
{
// FormatException: Convert.ChangeType("hello", typeof(double), ...);
}
catch (InvalidCastException)
{
// InvalidCastException: Convert.ChangeType(4.0d, typeof(Rectangle), ...);
}
if (convertedOperand == null)
{
return operatorType == ComparisonConditionType.NotEqual;
}
int comparison = leftOperand.CompareTo((IComparable)convertedOperand);
switch (operatorType)
{
case ComparisonConditionType.Equal:
return comparison == 0;
case ComparisonConditionType.NotEqual:
return comparison != 0;
case ComparisonConditionType.LessThan:
return comparison < 0;
case ComparisonConditionType.LessThanOrEqual:
return comparison <= 0;
case ComparisonConditionType.GreaterThan:
return comparison > 0;
case ComparisonConditionType.GreaterThanOrEqual:
return comparison >= 0;
}
return false;
}
private static bool Compare(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
if (leftOperand != null && rightOperand != null)
{
rightOperand = TypeConverterHelper.Convert(rightOperand.ToString(), leftOperand.GetType().FullName);
}
IComparable comparable = leftOperand as IComparable;
IComparable comparable2 = rightOperand as IComparable;
if (comparable != null && comparable2 != null)
{
return DataTriggerBehavior.EvaluateComparable(comparable, operatorType, comparable2);
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
return object.Equals(leftOperand, rightOperand);
case ComparisonConditionType.NotEqual:
return !object.Equals(leftOperand, rightOperand);
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
if (comparable == null && comparable2 == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "InvalidOperands", new object[]
{
(leftOperand != null) ? leftOperand.GetType().Name : "null",
(rightOperand != null) ? rightOperand.GetType().Name : "null",
operatorType.ToString()
}));
}
if (comparable == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "InvalidLeftOperand", new object[]
{
(leftOperand != null) ? leftOperand.GetType().Name : "null",
operatorType.ToString()
}));
}
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "InvalidRightOperand", new object[]
{
(rightOperand != null) ? rightOperand.GetType().Name : "null",
operatorType.ToString()
}));
default:
return false;
}
}
/// <summary>
/// This method evaluates operands.
/// </summary>
/// <param name="leftOperand">Left operand from the LeftOperand property.</param>
/// <param name="operatorType">Operator from Operator property.</param>
/// <param name="rightOperand">Right operand from the RightOperand property.</param>
/// <returns>Returns true if the condition is met; otherwise, returns false.</returns>
internal static bool EvaluateImpl(object leftOperand, ComparisonConditionType operatorType, object rightOperand)
{
bool result = false;
if (leftOperand != null)
{
Type leftType = leftOperand.GetType();
if (rightOperand != null)
{
TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(leftType);
rightOperand = TypeConverterHelper.DoConversionFrom(typeConverter, rightOperand);
}
}
IComparable leftComparableOperand = leftOperand as IComparable;
IComparable rightComparableOperand = rightOperand as IComparable;
// If both operands are comparable, use arithmetic comparison
if (leftComparableOperand != null && rightComparableOperand != null)
{
return(EvaluateComparable(leftComparableOperand, operatorType, rightComparableOperand));
}
switch (operatorType)
{
case ComparisonConditionType.Equal:
result = Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.NotEqual:
result = !Equals(leftOperand, rightOperand);
break;
case ComparisonConditionType.GreaterThan:
case ComparisonConditionType.GreaterThanOrEqual:
case ComparisonConditionType.LessThan:
case ComparisonConditionType.LessThanOrEqual:
if (leftComparableOperand == null && rightComparableOperand == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
ExceptionStringTable.InvalidOperands,
leftOperand != null ? leftOperand.GetType().Name : "null",
rightOperand != null ? rightOperand.GetType().Name : "null",
operatorType.ToString()));
}
else if (leftComparableOperand == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
ExceptionStringTable.InvalidLeftOperand,
leftOperand != null ? leftOperand.GetType().Name : "null",
operatorType.ToString()));
}
else
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
ExceptionStringTable.InvalidRightOperand,
rightOperand != null ? rightOperand.GetType().Name : "null",
operatorType.ToString()));
}
}
return(result);
}
