public virtual T GetValueFromObject <T>(object value)
{
Type t = typeof(T);
if (value == null)
{
if (t.IsValueType)
{
throw new InvalidCastException("Cannot set an object that have a ValueType to null.");
}
return((T)(object)null);
}
// value is already of the correct type.
if (t == typeof(object))
{
return((T)(object)value);
}
// TODO: Consider calling Type s = PropFactory.GetTypeFromValue(value);
Type vType = value.GetType();
// value is already of the correct type.
if (vType == t)
{
return((T)(object)value);
}
object parameter = new TwoTypes(t, vType);
return((T)ValueConverter.ConvertBack(value, t, parameter, CultureInfo.CurrentCulture));
}
private object ConvertBack(object value, BinarySerializationContext context)
{
if (ValueConverter == null)
{
return(value);
}
return(ValueConverter.ConvertBack(value, ConverterParameter, context));
}
public virtual T GetValueFromString <T>(string value)
{
Type t = typeof(T);
Type s = typeof(string);
if (t == s)
{
return((T)(object)value);
}
object parameter = new TwoTypes(t, s);
return((T)ValueConverter.ConvertBack(value, t, parameter, CultureInfo.CurrentCulture));
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
Contract.Assume(targetTypes != null);
Contract.Assume(targetTypes.Length == 2);
var targetType = targetTypes[1];
Contract.Assume(targetType != null);
object convertedValue;
if (ValueConverter != null)
{
convertedValue = ValueConverter.ConvertBack(value, targetType, ValueConverterParameter ?? parameter, ValueConverterCulture ?? culture);
}
else if (value == null)
{
convertedValue = null;
}
else if (targetType.IsAssignableFrom(value.GetType()))
{
convertedValue = value;
}
else
{
var converter = TypeDescriptor.GetConverter(targetType);
if (converter == null || !converter.CanConvertFrom(value.GetType()))
{
Contract.Assume(PresentationTraceSources.DataBindingSource != null);
PresentationTraceSources.DataBindingSource.TraceEvent(
TraceEventType.Verbose,
0,
"Subscription: The value \"{0}\" cannot be converted back to the specified type \"{1}\".",
value.GetType(),
targetType);
convertedValue = DependencyProperty.UnsetValue;
}
else
{
convertedValue = converter.ConvertFrom(null, ValueConverterCulture ?? culture, value);
}
}
return(new[] { null, convertedValue });
}
bool IBindingBridgeInternal.SetValueToSource(object sourceObject, object value)
{
object prepared = ValueConverter == null ? value
: ValueConverter.ConvertBack(value,
SourcePropertyInfo.PropertyType,
ConverterParameter,
ConverterCulture ?? CultureInfo.CurrentUICulture
);
if (SourcePropertyInfo.GetValue(sourceObject, null) != prepared)
{
SourcePropertyInfo.SetValue(sourceObject, prepared, null);
return(true);
}
return(false);
}
protected void SetSourceItemValue([NotNull] TSourceItem sourceItem, [CanBeNull] TTargetItemValue targetItemValue)
{
var sourceItemValue = ValueConverter.ConvertBack(targetItemValue, typeof(TSourceItemValue));
if (sourceItemValue != BindingValue.UnsetValue)
{
try
{
SourceItemBinding.SetValue(sourceItem, (TSourceItemValue)sourceItemValue, _compositeItemBindingMode == BindingMode.TwoWay);
}
catch (Exception ex)
{
Log($"An \"{LogFormatter.FormatException(ex)}\" exception occurred while executing " +
$"\"{LogFormatter.FormatTypeName(SourceItemBinding)}.{nameof(SourceItemBinding.SetValue)}\" method.");
}
}
}
private object ConvertbackValue(object value, Type targetType)
{
if (value != null && value.GetType() == targetType)
{
return(value);
}
object convertedValue = value;
var memberType = Member.GetMemberType();
try
{
if (ValueConverter != null)
{
var parameter = GetConverterParameter();
convertedValue = ValueConverter.ConvertBack(value, memberType, parameter, CultureInfo.CurrentUICulture);
}
if (targetType != null)
{
var typeCode = System.Convert.GetTypeCode(convertedValue);
if (typeCode != TypeCode.Object && typeCode != TypeCode.Empty)
{
try
{
convertedValue = System.Convert.ChangeType(convertedValue, targetType);
}
catch (InvalidCastException)
{
}
}
}
}
catch (FormatException)
{
var message = string.Format("The value \"{0}\" is of type {1} but the {2} \"{3}\" is of type {4}. You need to specify an IValueConverter to convert it.",
convertedValue, convertedValue.GetType(), Member.GetMemberTypeName(), Member.Name, memberType);
throw new FormatException(message);
}
catch (NotImplementedException)
{
}
return(convertedValue);
}
private void SourceItemCommandBinding_CanExecuteChanged([NotNull] object sender, [NotNull] EventArgs e)
{
if (TargetItemBinding is ITargetItemCommandListener <TTargetItem> targetItemCommandListener &&
TargetItemBinding.TryGetItem(out var targetItem) &&
SourceItemBinding.TryGetItem(out var sourceItem))
{
if (TryGetTargetItemValue(targetItem, out var targetItemCommandParameter))
{
var sourceItemCommandParameter = ValueConverter.ConvertBack(targetItemCommandParameter, typeof(TSourceItemValue));
if (sourceItemCommandParameter != BindingValue.UnsetValue)
{
var canExecute = SourceItemBinding.CanExecute(sourceItem, (TSourceItemValue)sourceItemCommandParameter);
targetItemCommandListener.HandleCanExecuteCommandChanged(targetItem, canExecute);
}
}
}
}
/// <summary>
/// Used to convert the value that is produced by the binding target to a type
/// assignable to the binding source.
/// </summary>
private void ConvertBack(object sender, ConvertEventArgs args)
{
args.Value = ValueConverter.ConvertBack(args.Value, args.DesiredType, null, CultureInfo.CurrentCulture);
}
private void OnTargetEndPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (context != null && SynchronizationContext.Current != context)
{
context.Post((o) =>
{
SynchronizationContext.SetSynchronizationContext(context);
OnTargetEndPropertyChanged(sender, e);
}, this);
return;
}
if (Mode == BindingMode.OneWayToTarget)
{
return;
}
var targetToken = TargetPath.Substring(TargetPath.LastIndexOf('.') + 1);
if (e.PropertyName != targetToken)
{
return;
}
var sourceObject = sourceObjects.Last();
var sourceType = sourceObject.GetType();
var sourceInfo = sourceInfos.Last();
var targetObject = targetObjects.Last().Target;
if (targetObject == null)
{
Deactivate();
return;
}
object value = null;
if (targetObject.GetType().IsArray)
{
value = ((Array)targetObject).GetValue(targetIndices.Last().Cast <int>().ToArray());
}
else
{
value = targetInfos.Last().GetValue(targetObject, targetIndices.Last());
}
if (ValueConverter != null)
{
value = ValueConverter.ConvertBack(value, sourceInfo.PropertyType, ValueConverterParameter);
}
else
{
value = GetConvertedValue(value, sourceType.IsArray ? sourceType.GetElementType() : sourceInfo.PropertyType);
}
if (sourceType.IsArray)
{
((Array)sourceObject).SetValue(value, sourceIndices.Last().Cast <int>().ToArray());
}
else
{
sourceInfo.SetValue(sourceObject, value, sourceIndices.Last());
}
}
private object ConvertBack(object value, BinaryDataSerializationContext context)
{
return(ValueConverter.ConvertBack(value, ConverterParameter, context));
}
public void Test_Invalid_Convert_Back()
{
ValueConverter vc = new ValueConverter();
Assert.IsTrue((double)vc.ConvertBack(null, typeof(double), null, new System.Globalization.CultureInfo("en-us")) == 0);
}
