private static object TryAddition(object currentValue, object value) { Type type = value.GetType(); Type type2 = currentValue.GetType(); MethodInfo methodInfo = null; object obj2 = value; MethodInfo[] methods = type2.GetMethods(); foreach (MethodInfo methodInfo2 in methods) { if (string.Compare(methodInfo2.Name, "op_Addition", StringComparison.Ordinal) == 0) { ParameterInfo[] parameters = methodInfo2.GetParameters(); Type parameterType = parameters[1].ParameterType; if (parameters[0].ParameterType.IsAssignableFrom(type2)) { if (!parameterType.IsAssignableFrom(type)) { TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(parameterType); if (!typeConverter.CanConvertFrom(type)) { continue; } obj2 = TypeConverterHelper.DoConversionFrom(typeConverter, value); } if (methodInfo != null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "ChangePropertyActionAmbiguousAdditionOperationExceptionMessage", new object[1] { type2.Name })); } methodInfo = methodInfo2; } } } if (methodInfo != null) { return(methodInfo.Invoke(null, new object[2] { currentValue, obj2 })); } return(value); }
private object IncrementCurrentValue(PropertyInfo propertyInfo) { if (!propertyInfo.CanRead) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "ChangePropertyActionCannotIncrementWriteOnlyPropertyExceptionMessage", new object[1] { propertyInfo.Name })); } object value = propertyInfo.GetValue(base.Target, null); object obj = value; Type propertyType = propertyInfo.PropertyType; TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(propertyInfo.PropertyType); object obj2 = Value; if (obj2 == null || value == null) { return(obj2); } if (typeConverter.CanConvertFrom(obj2.GetType())) { obj2 = TypeConverterHelper.DoConversionFrom(typeConverter, obj2); } if (typeof(double).IsAssignableFrom(propertyType)) { return((double)value + (double)obj2); } if (typeof(int).IsAssignableFrom(propertyType)) { return((int)value + (int)obj2); } if (typeof(float).IsAssignableFrom(propertyType)) { return((float)value + (float)obj2); } if (typeof(string).IsAssignableFrom(propertyType)) { return((string)value + (string)obj2); } return(TryAddition(value, obj2)); }
protected override void Invoke(object parameter) { if (base.AssociatedObject != null && !string.IsNullOrEmpty(PropertyName) && base.Target != null) { Type type = base.Target.GetType(); PropertyInfo property = type.GetProperty(PropertyName); ValidateProperty(property); object obj = Value; TypeConverter typeConverter = TypeConverterHelper.GetTypeConverter(property.PropertyType); Exception ex = null; try { if (Value != null) { if (typeConverter != null && typeConverter.CanConvertFrom(Value.GetType())) { obj = typeConverter.ConvertFrom(Value); } else { typeConverter = TypeConverterHelper.GetTypeConverter(Value.GetType()); if (typeConverter != null && typeConverter.CanConvertTo(property.PropertyType)) { obj = typeConverter.ConvertTo(Value, property.PropertyType); } } } if (Duration.HasTimeSpan) { ValidateAnimationPossible(type); object currentPropertyValue = GetCurrentPropertyValue(base.Target, property); AnimatePropertyChange(property, currentPropertyValue, obj); } else { if (Increment) { obj = IncrementCurrentValue(property); } property.SetValue(base.Target, obj, new object[0]); } } catch (FormatException ex2) { ex = ex2; } catch (ArgumentException ex3) { ex = ex3; } catch (MethodAccessException ex4) { ex = ex4; } if (ex != null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "ChangePropertyActionCannotSetValueExceptionMessage", new object[3] { (Value != null) ? Value.GetType().Name : "null", PropertyName, property.PropertyType.Name }), ex); } } }