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 is not 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 is not null && sourceConverter != sourceTypeTypeConverter && sourceConverter.CanConvertTo(targetType))
{
return(sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType));
}
TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType);
if (targetConverter is not 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 is not 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 is not null && sourceConverter.CanConvertTo(targetType))
{
return(sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType));
}
/// <devdoc>
///
/// Converts a value entered by the end user (through UI) into the corresponding binary value.
///
/// - Converts formatted representations of 'null' into DBNull
/// - Performs some special-case conversions (eg. CheckState to Boolean)
/// - Uses TypeConverters or IConvertible where appropriate
/// - Throws a FormatException is no suitable conversion can be found
///
/// </devdoc>
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)
{
CheckState state = (CheckState)value;
if (state == CheckState.Indeterminate)
{
return(DBNull.Value);
}
// Explicit conversion from CheckState to Boolean
if (targetType == booleanType)
{
return(state == CheckState.Checked);
}
if (targetConverter == 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 == null)
{
targetConverter = targetTypeTypeConverter;
}
if (sourceConverter == 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));
}
