private ConvertTo ( ITypeDescriptorContext context, |
||
context | ITypeDescriptorContext | |
culture | ||
value | object | |
destinationType | Type | |
return | object |
private static object DoConversion(object value, Type toType, CultureInfo culture) { if ((value is IConvertible) || (value == null)) { try { return(System.Convert.ChangeType(value, toType, culture)); } catch (Exception) { return(DependencyProperty.UnsetValue); } } else { System.ComponentModel.TypeConverter typeConverter = TypeDescriptor.GetConverter(value); if (typeConverter.CanConvertTo(toType)) { return(typeConverter.ConvertTo(null, culture, value, toType)); } } return(DependencyProperty.UnsetValue); }
/// <summary> /// 转换简单类型 /// </summary> /// <param name="value"></param> /// <param name="type"></param> /// <returns></returns> private static object ConvertObj(object value, Type type) { object returnValue; if ((value == null) || type.IsInstanceOfType(value)) { return(value); } string str = value as string; if ((str != null) && (str.Length == 0)) { return(null); } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type); bool flag = converter.CanConvertFrom(value.GetType()); if (!flag) { converter = TypeDescriptor.GetConverter(value.GetType()); } if (!flag && !converter.CanConvertTo(type)) { throw new InvalidOperationException("无法转换成类型:" + value.ToString() + "==>" + type); } try { returnValue = flag ? converter.ConvertFrom(null, null, value) : converter.ConvertTo(null, null, value, type); } catch (Exception e) { throw new InvalidOperationException("类型转换出错:" + value.ToString() + "==>" + type, e); } return(returnValue); }
/// <inheritdoc /> public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args) { System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType); if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertFrom(value.GetType())) { try { result = converter.ConvertFrom(null, args.Culture, value); return(true); } catch { } } converter = TypeDescriptor.GetConverter(value.GetType()); if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertTo(destinationType)) { try { result = converter.ConvertTo(null, args.Culture, value, destinationType); return(true); } catch { } } result = null; return(false); }
private DateTime GetDateTime(object value, TypeConverter converter) { if (typeof(DateTime).IsAssignableFrom(value.GetType())) return (DateTime) value; else return (DateTime) converter.ConvertTo(value, typeof(DateTime)); }
/// <summary> /// Converts the given value object to the specified type, using the specified context and culture information. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context.</param> /// <param name="culture">A <see cref="T:System.Globalization.CultureInfo"></see>. If null is passed, the current culture is assumed.</param> /// <param name="value">The <see cref="T:System.Object"></see> to convert.</param> /// <param name="destinationType">The <see cref="T:System.Type"></see> to convert the value parameter to.</param> /// <returns> /// An <see cref="T:System.Object"></see> that represents the converted value. /// </returns> /// <exception cref="T:System.NotSupportedException">The conversion can not be performed. </exception> /// <exception cref="T:System.ArgumentNullException">The destinationType parameter is null. </exception> public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { if (destinationType == typeof(string) && value != null) { return(((DateTime)value).ToString(format, GetCulture(culture).DateTimeFormat)); } else { return(baseTypeConverter.ConvertTo(context, culture, value, destinationType)); } }
private static object ConvertSimpleType(CultureInfo culture, object value, Type destinationType) { if (value == null || destinationType.IsInstanceOfType(value)) { return(value); } // if this is a user-input value but the user didn't type anything, return no value string valueAsString = value as string; if (valueAsString != null && valueAsString.Trim().Length == 0) { return(null); } //modified by Yang Li //TypeConverter converter = TypeDescriptor.GetConverter(destinationType); System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType); bool canConvertFrom = converter.CanConvertFrom(value.GetType()); if (!canConvertFrom) { converter = TypeDescriptor.GetConverter(value.GetType()); } if (!(canConvertFrom || converter.CanConvertTo(destinationType))) { string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_NoConverterExists, value.GetType().FullName, destinationType.FullName); throw new InvalidOperationException(message); } try { object convertedValue = (canConvertFrom) ? converter.ConvertFrom(null /* context */, culture, value) : converter.ConvertTo(null /* context */, culture, value, destinationType); return(convertedValue); } catch (Exception ex) { string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_ConversionThrew, value.GetType().FullName, destinationType.FullName); throw new InvalidOperationException(message, ex); } }
public virtual object ParseFormattedValue (object formattedValue, DataGridViewCellStyle cellStyle, TypeConverter formattedValueTypeConverter, TypeConverter valueTypeConverter) { if (cellStyle == null) throw new ArgumentNullException ("cellStyle is null."); if (FormattedValueType == null) throw new FormatException ("The System.Windows.Forms.DataGridViewCell.FormattedValueType property value is null."); if (formattedValue == null) throw new ArgumentException ("formattedValue is null."); if (ValueType == null) throw new FormatException ("valuetype is null"); if (!FormattedValueType.IsAssignableFrom (formattedValue.GetType ())) throw new ArgumentException ("formattedValue is not of formattedValueType."); if (formattedValueTypeConverter == null) formattedValueTypeConverter = FormattedValueTypeConverter; if (valueTypeConverter == null) valueTypeConverter = ValueTypeConverter; if (valueTypeConverter != null && valueTypeConverter.CanConvertFrom (FormattedValueType)) return valueTypeConverter.ConvertFrom (formattedValue); if (formattedValueTypeConverter != null && formattedValueTypeConverter.CanConvertTo (ValueType)) return formattedValueTypeConverter.ConvertTo (formattedValue, ValueType); return Convert.ChangeType (formattedValue, ValueType); }
public static bool Convert(object val, Type targetType, out object result) { result = val; // Trivial cases if (val == null) { // Cannot convert null to value type return(!targetType.IsValueType); } if (targetType.IsAssignableFrom(val.GetType())) { return(true); } // Custom type conversions if (_customTypeConverter != null) { if (_customTypeConverter(val, targetType, out result)) { return(true); } } // TODO: typeof(Nullable<T>) // Built-in type conversions if (val.GetType() == typeof(string) && targetType == typeof(Type)) { // string -> Type result = Type.GetType(val.ToString()); return(result != null); } // Enumerations if (val.GetType() == typeof(string) && targetType.IsEnum) { // string -> Enum result = Enum.Parse(targetType, (string)val); return(true); } // String target type must be done before enumerations are tried - else, the string will be treated as enumeration if (targetType.IsAssignableFrom(typeof(string))) { // * -> string result = val.ToString(); return(true); } // Collection types Type enumerableType; Type entryType; ReflectionHelper.FindImplementedEnumerableType(targetType, out enumerableType, out entryType); if (enumerableType != null) // Targets IList, ICollection, IList<>, ICollection<> { ICollection col; if (!ToCollection(val, entryType, out col)) { return(false); } List <object> resultList = col.Cast <object>().ToList(); result = resultList; return(true); } ICollection sourceCol = val as ICollection; if (sourceCol != null && sourceCol.Count == 1) // From collection to non-collection target { // Use the first (single) item of a collection or dictionary IEnumerator enumerator = sourceCol.GetEnumerator(); enumerator.MoveNext(); object item = enumerator.Current; if (Convert(item, targetType, out result)) // Single collection item { return(true); } KeyValuePair <object, object>?kvp = item as KeyValuePair <object, object>?; if (kvp.HasValue && Convert(kvp.Value.Value, targetType, out result)) // Value of single dictionary entry - generic dictionary { IDisposable d = kvp.Value.Key as IDisposable; if (d != null) { d.Dispose(); } return(true); } DictionaryEntry?entry = item as DictionaryEntry?; if (entry.HasValue && Convert(entry.Value.Value, targetType, out result)) // Value of single dictionary entry - legacy dictionary { IDisposable d = entry.Value.Key as IDisposable; if (d != null) { d.Dispose(); } return(true); } } // Simple type conversions System.ComponentModel.TypeConverter tc = TypeDescriptor.GetConverter(targetType); if (tc != null && tc.CanConvertFrom(val.GetType())) { try { result = tc.ConvertFrom(null, CultureInfo.InvariantCulture, val); return(true); } catch { } } tc = TypeDescriptor.GetConverter(val); if (tc != null && tc.CanConvertTo(targetType)) { result = tc.ConvertTo(val, targetType); return(true); } return(false); }
/// <devdoc> /// /// Converts a value into a format suitable for display to the end user. /// /// - Converts DBNull or null into a suitable formatted representation of 'null' /// - Performs some special-case conversions (eg. Boolean to CheckState) /// - Uses TypeConverters or IConvertible where appropriate /// - Throws a FormatException is no suitable conversion can be found /// /// </devdoc> private static object FormatObjectInternal(object value, Type targetType, TypeConverter sourceConverter, TypeConverter targetConverter, string formatString, IFormatProvider formatInfo, object formattedNullValue) { if (value == System.DBNull.Value || value == 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 == 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 == null) { sourceConverter = sourceTypeTypeConverter; } if (targetConverter == 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)); }
/// <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)); }
private static object FormatObjectInternal(object value, System.Type targetType, TypeConverter sourceConverter, TypeConverter targetConverter, string formatString, IFormatProvider formatInfo, object formattedNullValue) { if ((value == DBNull.Value) || (value == null)) { if (formattedNullValue != null) { return formattedNullValue; } if (targetType == stringType) { return string.Empty; } if (targetType == checkStateType) { return CheckState.Indeterminate; } return null; } if (((targetType == stringType) && (value is IFormattable)) && !string.IsNullOrEmpty(formatString)) { return (value as IFormattable).ToString(formatString, formatInfo); } System.Type type = value.GetType(); TypeConverter converter = TypeDescriptor.GetConverter(type); if (((sourceConverter != null) && (sourceConverter != converter)) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } TypeConverter converter2 = TypeDescriptor.GetConverter(targetType); if (((targetConverter != null) && (targetConverter != converter2)) && targetConverter.CanConvertFrom(type)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (targetType == checkStateType) { if (type == booleanType) { return (((bool) value) ? CheckState.Checked : CheckState.Unchecked); } if (sourceConverter == null) { sourceConverter = converter; } if ((sourceConverter != null) && sourceConverter.CanConvertTo(booleanType)) { return (((bool) sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType)) ? CheckState.Checked : CheckState.Unchecked); } } if (targetType.IsAssignableFrom(type)) { return value; } if (sourceConverter == null) { sourceConverter = converter; } if (targetConverter == null) { targetConverter = converter2; } if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if ((targetConverter != null) && targetConverter.CanConvertFrom(type)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (!(value is IConvertible)) { throw new FormatException(GetCantConvertMessage(value, targetType)); } return ChangeType(value, targetType, formatInfo); }
private static object ParseObjectInternal(object value, System.Type targetType, System.Type sourceType, TypeConverter targetConverter, TypeConverter sourceConverter, IFormatProvider formatInfo, object formattedNullValue) { if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || (value == DBNull.Value)) { return DBNull.Value; } TypeConverter converter = TypeDescriptor.GetConverter(targetType); if (((targetConverter != null) && (converter != targetConverter)) && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } TypeConverter converter2 = TypeDescriptor.GetConverter(sourceType); if (((sourceConverter != null) && (converter2 != sourceConverter)) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (value is string) { object obj2 = InvokeStringParseMethod(value, targetType, formatInfo); if (obj2 != parseMethodNotFound) { return obj2; } } else if (value is CheckState) { CheckState state = (CheckState) value; if (state == CheckState.Indeterminate) { return DBNull.Value; } if (targetType == booleanType) { return (state == CheckState.Checked); } if (targetConverter == null) { targetConverter = converter; } if ((targetConverter != null) && targetConverter.CanConvertFrom(booleanType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked); } } else if ((value != null) && targetType.IsAssignableFrom(value.GetType())) { return value; } if (targetConverter == null) { targetConverter = converter; } if (sourceConverter == null) { sourceConverter = converter2; } if ((targetConverter != null) && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (!(value is IConvertible)) { throw new FormatException(GetCantConvertMessage(value, targetType)); } return ChangeType(value, targetType, formatInfo); }
public override object ConvertTo(cm.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { return(etoConverter.ConvertTo(null, culture, value, destinationType)); }
public static object ChangeType(object value, Type destinationType, CultureInfo culture) { if (value == null || value.IsDbNull()) { return((!destinationType.IsValueType()) ? null : Activator.CreateInstance(destinationType)); } Type type = value.GetType(); if (destinationType == type || destinationType.IsAssignableFrom(type)) { return(value); } if (destinationType.IsGenericType()) { Type genericTypeDefinition = destinationType.GetGenericTypeDefinition(); if (genericTypeDefinition == typeof(Nullable <>)) { Type destinationType2 = destinationType.GetGenericArguments()[0]; object obj = ChangeType(value, destinationType2, culture); return(Activator.CreateInstance(destinationType, obj)); } } if (destinationType.IsEnum()) { string text = value as string; return((text == null) ? value : Enum.Parse(destinationType, text, true)); } if (destinationType == typeof(bool)) { if ("0".Equals(value)) { return(false); } if ("1".Equals(value)) { return(true); } } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertTo(destinationType)) { return(converter.ConvertTo(null, culture, value, destinationType)); } System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType); if (converter2 != null && converter2.CanConvertFrom(type)) { return(converter2.ConvertFrom(null, culture, value)); } Type[] array = new Type[2] { type, destinationType }; foreach (Type type2 in array) { foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods()) { if (publicStaticMethod2.IsSpecialName && (publicStaticMethod2.Name == "op_Implicit" || publicStaticMethod2.Name == "op_Explicit") && destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType)) { ParameterInfo[] parameters = publicStaticMethod2.GetParameters(); if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type)) { try { return(publicStaticMethod2.Invoke(null, new object[1] { value })); } catch (TargetInvocationException ex) { throw ex.Unwrap(); } } } } } if (type == typeof(string)) { try { MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider)); if (publicStaticMethod != null) { return(publicStaticMethod.Invoke(null, new object[2] { value, culture })); } publicStaticMethod = ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string)); if (publicStaticMethod != null) { return(publicStaticMethod.Invoke(null, new object[1] { value })); } } catch (TargetInvocationException ex2) { throw ex2.Unwrap(); } } if (destinationType == typeof(TimeSpan)) { return(TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture))); } return(Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture)); }
private static bool TryConvertTo( object value, Type targetType, CultureInfo culture, TypeConverter converter, out object result ) { if( converter != null ) { try { result = converter.ConvertTo( null, culture, value, targetType ); return true; } catch { // We'll try to convert the value another way. } if( ( value != null ) && ( converter.CanConvertFrom( value.GetType() ) ) ) { try { var newValue = converter.ConvertFrom( null, culture, value ); result = converter.ConvertTo( null, culture, newValue, targetType ); return true; } catch { } } } result = null; return false; }
protected virtual object GetFormattedValue (object value, int rowIndex, ref DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context) { if (DataGridView == null) return null; if (rowIndex < 0 || rowIndex >= DataGridView.RowCount) throw new ArgumentOutOfRangeException ("rowIndex"); // Give the user a chance to custom format if (!(this is DataGridViewRowHeaderCell)) { DataGridViewCellFormattingEventArgs e = new DataGridViewCellFormattingEventArgs (ColumnIndex, rowIndex, value, FormattedValueType, cellStyle); DataGridView.OnCellFormattingInternal (e); if (e.FormattingApplied) return e.Value; cellStyle = e.CellStyle; value = e.Value; } if (value == null || (cellStyle != null && value == cellStyle.DataSourceNullValue)) { if (FormattedValueType == typeof (string)) return String.Empty; } if (FormattedValueType == typeof(string) && value is IFormattable && !String.IsNullOrEmpty (cellStyle.Format)) return ((IFormattable) value).ToString (cellStyle.Format, cellStyle.FormatProvider); if (value != null && FormattedValueType.IsAssignableFrom (value.GetType())) return value; if (formattedValueTypeConverter == null) formattedValueTypeConverter = FormattedValueTypeConverter; if (valueTypeConverter == null) valueTypeConverter = ValueTypeConverter; if (valueTypeConverter != null && valueTypeConverter.CanConvertTo (FormattedValueType)) return valueTypeConverter.ConvertTo (value, FormattedValueType); if (formattedValueTypeConverter != null && formattedValueTypeConverter.CanConvertFrom (ValueType)) return formattedValueTypeConverter.ConvertFrom (value); return Convert.ChangeType (value, FormattedValueType); }
public void CheckConversion(object check, object expect, TypeConverter conv, Type type, bool test_from, bool test_to, CultureInfo culture) { object obj; object result; obj = check; if (debug > 0) { Console.WriteLine("{0}: CheckConversion, checking {1}({2}) <-> {3}({4})", conv.ToString(), check.GetType().ToString(), check.ToString(), type.ToString(), expect != null ? expect.ToString() : "null"); } if (test_to) { obj = conv.ConvertTo(null, culture, check, type); if (obj == null) { if (expect != null) { failed++; Console.WriteLine("{0}: ConvertTo failed, type {1}, expected {2}, got null", conv.ToString(), type.ToString(), expect.ToString()); } return; } // Intermediate verification if (expect != null && !obj.Equals(expect)) { failed++; if (verbose > 0) { Console.WriteLine("{0}: ConvertTo failed, type {1}, expected {2}, got {3}", conv.ToString(), type.ToString(), expect.ToString(), obj.ToString()); } } if (debug > 1) { Console.WriteLine("{0}: CheckConversion, ConvertTo result: '{1}')", conv.ToString(), obj); } } if (test_from) { result = conv.ConvertFrom(null, culture, obj); if (test_to) { // Roundtrip check if (!check.Equals(result)) { failed++; if (verbose > 0) { Console.WriteLine("{0}: ConvertTo/ConvertFrom roundtrip failed, type {1}", conv.ToString(), type.ToString()); } } } else { if (!expect.Equals(result)) { failed++; if (verbose > 0) { Console.WriteLine("{0}: ConvertFrom failed, type {1}", conv.ToString(), type.ToString()); } } } if (debug > 1) { Console.WriteLine("{0}: CheckConversion, ConvertFrom result: '{1}')", conv.ToString(), result); } } }
/// <summary> /// Converts the given value object to the specified type, using the specified /// context and culture information. /// </summary> /// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param> /// <param name="culture">A System.Globalization.CultureInfo. If null is passed, the current culture /// is assumed.</param> /// <param name="value">The System.Object to convert.</param> /// <param name="destinationType">The System.Type to convert the value parameter to.</param> /// <returns>An System.Object that represents the converted value.</returns> public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { TypeConverter converter = TypeDescriptor.GetConverter(typeof(double)); return(converter.ConvertTo(context, culture, value, destinationType)); }