private object FormatObject(object value)
{
// We will not format the object when the control is in design time.
// This is because if we bind a boolean property on a control to a
// row that is full of DBNulls then we cause problems in the shell.
if (ControlAtDesignTime())
{
return(value);
}
Type type = propInfo.PropertyType;
if (formattingEnabled)
{
// -------------------------------
// Behavior for Whidbey and beyond
// -------------------------------
// Fire the Format event so that user code gets a chance to supply the formatted value for us
ConvertEventArgs e = new ConvertEventArgs(value, type);
OnFormat(e);
if (e.Value != value)
{
// If event handler replaced parsed value with formatted value, use that
return(e.Value);
}
else
{
// Otherwise format the parsed value ourselves
TypeConverter fieldInfoConverter = null;
if (bindToObject.FieldInfo != null)
{
fieldInfoConverter = bindToObject.FieldInfo.Converter;
}
return(Formatter.FormatObject(value, type, fieldInfoConverter, propInfoConverter, formatString, formatInfo, nullValue, dsNullValue));
}
}
else
{
// ----------------------------
// Behavior for RTM and Everett [DO NOT MODIFY!]
// ----------------------------
// first try: use the Format event
ConvertEventArgs e = new ConvertEventArgs(value, type);
OnFormat(e);
object ret = e.Value;
// Approved breaking-change behavior between RTM and Everett: Fire the Format event even if the control property is of type
// Object (RTM used to skip the event for properties of this type).
if (type == typeof(object))
{
return(value);
}
// stop now if we have a value of a compatible type
if (ret != null && (ret.GetType().IsSubclassOf(type) || ret.GetType() == type))
{
return(ret);
}
// second try: use type converter for the desiredType
TypeConverter typeConverter = TypeDescriptor.GetConverter(value != null ? value.GetType() : typeof(object));
if (typeConverter != null && typeConverter.CanConvertTo(type))
{
ret = typeConverter.ConvertTo(value, type);
return(ret);
}
// last try: use Convert.ChangeType
if (value is IConvertible)
{
ret = Convert.ChangeType(value, type, CultureInfo.CurrentCulture);
if (ret != null && (ret.GetType().IsSubclassOf(type) || ret.GetType() == type))
{
return(ret);
}
}
// time to fail:
throw new FormatException(SR.ListBindingFormatFailed);
}
}
private static object FormatObjectInternal(object value,
Type targetType,
TypeConverter sourceConverter,
TypeConverter targetConverter,
string formatString,
IFormatProvider formatInfo,
object formattedNullValue)
{
if (value == System.DBNull.Value || value is null)
{
//
// Convert DBNull to the formatted representation of 'null' (if possible)
//
if (formattedNullValue != null)
{
return(formattedNullValue);
}
//
// Convert DBNull or null to a specific 'known' representation of null (otherwise fail)
//
if (targetType == stringType)
{
return(string.Empty);
}
if (targetType == checkStateType)
{
return(CheckState.Indeterminate);
}
// Just pass null through: if this is a value type, it's been unwrapped here, so we return null
// and the caller has to wrap if appropriate.
return(null);
}
//
// Special case conversions
//
if (targetType == stringType)
{
if (value is IFormattable && !string.IsNullOrEmpty(formatString))
{
return((value as IFormattable).ToString(formatString, formatInfo));
}
}
//The converters for properties should take precedence. Unfortunately, we don't know whether we have one. Check vs. the
//type's TypeConverter. We're punting the case where the property-provided converter is the same as the type's converter.
Type sourceType = value.GetType();
TypeConverter sourceTypeTypeConverter = TypeDescriptor.GetConverter(sourceType);
if (sourceConverter != null && sourceConverter != sourceTypeTypeConverter && sourceConverter.CanConvertTo(targetType))
{
return(sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType));
}
TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType);
if (targetConverter != null && targetConverter != targetTypeTypeConverter && targetConverter.CanConvertFrom(sourceType))
{
return(targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value));
}
if (targetType == checkStateType)
{
if (sourceType == booleanType)
{
return(((bool)value) ? CheckState.Checked : CheckState.Unchecked);
}
else
{
if (sourceConverter is null)
{
sourceConverter = sourceTypeTypeConverter;
}
if (sourceConverter != null && sourceConverter.CanConvertTo(booleanType))
{
return((bool)sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType)
? CheckState.Checked : CheckState.Unchecked);
}
}
}
if (targetType.IsAssignableFrom(sourceType))
{
return(value);
}
//
// If explicit type converters not provided, supply default ones instead
//
if (sourceConverter is null)
{
sourceConverter = sourceTypeTypeConverter;
}
if (targetConverter is null)
{
targetConverter = targetTypeTypeConverter;
}
//
// Standardized conversions
//
if (sourceConverter != null && sourceConverter.CanConvertTo(targetType))
{
return(sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType));
}
else if (targetConverter != null && targetConverter.CanConvertFrom(sourceType))
{
return(targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value));
}
else if (value is IConvertible)
{
return(ChangeType(value, targetType, formatInfo));
}
//
// Fail if no suitable conversion found
//
throw new FormatException(GetCantConvertMessage(value, targetType));
}
private object ParseObject(object value)
{
Type type = this.bindToObject.BindToType;
if (formattingEnabled)
{
// -------------------------------
// Behavior for Whidbey and beyond
// -------------------------------
// Fire the Parse event so that user code gets a chance to supply the parsed value for us
ConvertEventArgs e = new ConvertEventArgs(value, type);
OnParse(e);
object newValue = e.Value;
if (!object.Equals(value, newValue))
{
// If event handler replaced formatted value with parsed value, use that
return(newValue);
}
else
{
// Otherwise parse the formatted value ourselves
TypeConverter fieldInfoConverter = null;
if (bindToObject.FieldInfo != null)
{
fieldInfoConverter = bindToObject.FieldInfo.Converter;
}
return(Formatter.ParseObject(value, type, (value == null ? propInfo.PropertyType : value.GetType()), fieldInfoConverter, propInfoConverter, formatInfo, nullValue, GetDataSourceNullValue(type)));
}
}
else
{
// ----------------------------
// Behavior for RTM and Everett [DO NOT MODIFY!]
// ----------------------------
ConvertEventArgs e = new ConvertEventArgs(value, type);
// first try: use the OnParse event
OnParse(e);
//
if (e.Value != null && (e.Value.GetType().IsSubclassOf(type) || e.Value.GetType() == type || e.Value is System.DBNull))
{
return(e.Value);
}
// second try: use the TypeConverter
TypeConverter typeConverter = TypeDescriptor.GetConverter(value != null ? value.GetType() : typeof(object));
if (typeConverter != null && typeConverter.CanConvertTo(type))
{
return(typeConverter.ConvertTo(value, type));
}
// last try: use Convert.ToType
if (value is IConvertible)
{
object ret = Convert.ChangeType(value, type, CultureInfo.CurrentCulture);
if (ret != null && (ret.GetType().IsSubclassOf(type) || ret.GetType() == type))
{
return(ret);
}
}
// time to fail: (RTM/Everett just returns null, whereas Whidbey throws an exception)
return(null);
}
}
private static object ParseObjectInternal(object value,
Type targetType,
Type sourceType,
TypeConverter targetConverter,
TypeConverter sourceConverter,
IFormatProvider formatInfo,
object formattedNullValue)
{
//
// Convert the formatted representation of 'null' to DBNull (if possible)
//
if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || value == System.DBNull.Value)
{
return(System.DBNull.Value);
}
//
// Special case conversions
//
TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType);
if (targetConverter != null && targetTypeTypeConverter != targetConverter && targetConverter.CanConvertFrom(sourceType))
{
return(targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value));
}
TypeConverter sourceTypeTypeConverter = TypeDescriptor.GetConverter(sourceType);
if (sourceConverter != null && sourceTypeTypeConverter != sourceConverter && sourceConverter.CanConvertTo(targetType))
{
return(sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType));
}
if (value is string)
{
// If target type has a suitable Parse method, use that to parse strings
object parseResult = InvokeStringParseMethod(value, targetType, formatInfo);
if (parseResult != parseMethodNotFound)
{
return(parseResult);
}
}
else if (value is CheckState state)
{
if (state == CheckState.Indeterminate)
{
return(DBNull.Value);
}
// Explicit conversion from CheckState to Boolean
if (targetType == booleanType)
{
return(state == CheckState.Checked);
}
if (targetConverter is null)
{
targetConverter = targetTypeTypeConverter;
}
if (targetConverter != null && targetConverter.CanConvertFrom(booleanType))
{
return(targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked));
}
}
else if (value != null && targetType.IsAssignableFrom(value.GetType()))
{
// If value is already of a compatible type, just go ahead and use it
return(value);
}
//
// If explicit type converters not provided, supply default ones instead
//
if (targetConverter is null)
{
targetConverter = targetTypeTypeConverter;
}
if (sourceConverter is null)
{
sourceConverter = sourceTypeTypeConverter;
}
//
// Standardized conversions
//
if (targetConverter != null && targetConverter.CanConvertFrom(sourceType))
{
return(targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value));
}
else if (sourceConverter != null && sourceConverter.CanConvertTo(targetType))
{
return(sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType));
}
else if (value is IConvertible)
{
return(ChangeType(value, targetType, formatInfo));
}
//
// Fail if no suitable conversion found
//
throw new FormatException(GetCantConvertMessage(value, targetType));
}