private static object TryAddition(object currentValue, object value)
{
object returnValue = null;
Type valueType = value.GetType();
Type additiveType = currentValue.GetType();
MethodInfo uniqueAdditionOperation = null;
object convertedValue = value;
foreach (MethodInfo additionOperation in additiveType.GetMethods())
{
if (string.Compare(additionOperation.Name, "op_Addition", StringComparison.Ordinal) != 0)
{
continue;
}
ParameterInfo[] parameters = additionOperation.GetParameters();
Debug.Assert(parameters.Length == 2, "op_Addition is expected to have 2 parameters");
Type secondParameterType = parameters[1].ParameterType;
if (!parameters[0].ParameterType.IsAssignableFrom(additiveType))
{
continue;
}
else if (!secondParameterType.IsAssignableFrom(valueType))
{
TypeConverter additionConverter = TypeConverterHelper.GetTypeConverter(secondParameterType);
if (additionConverter.CanConvertFrom(valueType))
{
convertedValue = TypeConverterHelper.DoConversionFrom(additionConverter, value);
}
else
{
continue;
}
}
if (uniqueAdditionOperation != null)
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture,
ExceptionStringTable.ChangePropertyActionAmbiguousAdditionOperationExceptionMessage,
additiveType.Name));
}
uniqueAdditionOperation = additionOperation;
}
if (uniqueAdditionOperation != null)
{
returnValue = uniqueAdditionOperation.Invoke(null, new object[] { currentValue, convertedValue });
}
else
{
// we couldn't figure out how to add, so pack it up and just set value
returnValue = value;
}
return(returnValue);
}
private object IncrementCurrentValue(PropertyInfo propertyInfo)
{
if (!propertyInfo.CanRead)
{
throw new InvalidOperationException(string.Format(
CultureInfo.CurrentCulture,
ExceptionStringTable.ChangePropertyActionCannotIncrementWriteOnlyPropertyExceptionMessage,
propertyInfo.Name));
}
object currentValue = propertyInfo.GetValue(this.Target, null);
object returnValue = currentValue;
Type propertyType = propertyInfo.PropertyType;
TypeConverter converter = TypeConverterHelper.GetTypeConverter(propertyInfo.PropertyType);
object value = this.Value;
if (value == null || currentValue == null)
{
// we can't increment by null, so we'll attempt to set it instead
// likewise, we can't increment, null by x, so we'll just set value instead
return(value);
}
if (converter.CanConvertFrom(value.GetType()))
{
value = TypeConverterHelper.DoConversionFrom(converter, value);
}
if (typeof(double).IsAssignableFrom(propertyType))
{
returnValue = (double)currentValue + (double)value;
}
else if (typeof(int).IsAssignableFrom(propertyType))
{
returnValue = (int)currentValue + (int)value;
}
else if (typeof(float).IsAssignableFrom(propertyType))
{
returnValue = (float)currentValue + (float)value;
}
else if (typeof(string).IsAssignableFrom(propertyType))
{
returnValue = (string)currentValue + (string)value;
}
else
{
returnValue = TryAddition(currentValue, value);
}
return(returnValue);
}
