public CanConvertFrom ( ITypeDescriptorContext context, Type sourceType ) : bool | ||
context | ITypeDescriptorContext | |
sourceType | Type | |
return | bool |
private static bool InnerConvertObjectToType(object obj, Type type, bool throwOnError, out object convertedObject) { Type originalType = obj.GetType(); OriginalTypeConverter converter = TypeDescriptor.GetConverter(type); if (converter.CanConvertFrom(originalType)) { try { convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, obj); return(true); } catch { if (throwOnError) { throw; } convertedObject = null; return(false); } } if (converter.CanConvertFrom(typeof(string)) && !(obj is DateTime)) { try { string text = TypeDescriptor.GetConverter(originalType).ConvertToInvariantString(obj); convertedObject = converter.ConvertFromInvariantString(text); return(true); } catch { if (throwOnError) { throw; } convertedObject = null; return(false); } } if (type.IsInstanceOfType(obj)) { convertedObject = obj; return(true); } if (throwOnError) { throw new InvalidOperationException(); } convertedObject = null; return(false); }
public void CheckConvert(int expect_from, int expect_to, TypeConverter conv, Type type) { int from_count = 0; int to_count = 0; foreach (Type t in typeof(int).Assembly.GetTypes ()) { if (conv.CanConvertFrom(null, t)) { from_count++; if (debug > 0) { Console.WriteLine("{0}: Conversion from {1} supported", conv.ToString(), t.ToString()); } } if (conv.CanConvertTo(null, t)) { to_count++; if (debug > 0) { Console.WriteLine("{0}: Conversion to {1} supported", conv.ToString(), t.ToString()); } } } #if not foreach (Type t in type.Assembly.GetTypes ()) { if (conv.CanConvertFrom(null, t)) { from_count++; if (debug > 0) { Console.WriteLine("{0}: Conversion from {1} supported", conv.ToString(), t.ToString()); } } if (conv.CanConvertTo(null, t)) { to_count++; if (debug > 0) { Console.WriteLine("{0}: Conversion to {1} supported", conv.ToString(), t.ToString()); } } } #endif if (from_count != expect_from) { if (verbose > 0) { Console.WriteLine("{0}: ConvertFrom expected {1}, returned {2}", conv.ToString(), expect_from, from_count); } failed++; } if (to_count != expect_to) { if (verbose > 0) { Console.WriteLine("{0}: ConvertTo expected {1}, returned {2}", conv.ToString(), expect_to, to_count); } failed++; } }
/// <summary> /// This method retrieves a set of CDSAttribute from a class. /// </summary> /// <param name="data">The class to examine.</param> /// <param name="conv">A converter function to turn the value in to a string.</param> /// <returns>Returns an enumerable collection of attributes and values.</returns> public static IEnumerable<KeyValuePair<CDSAttributeAttribute, string>> CDSAttributesRetrieve( this IXimuraContent data, TypeConverter conv) { List<KeyValuePair<PropertyInfo, CDSAttributeAttribute>> attrList = AH.GetPropertyAttributes<CDSAttributeAttribute>(data.GetType()); foreach (KeyValuePair<PropertyInfo, CDSAttributeAttribute> reference in attrList) { PropertyInfo pi = reference.Key; if (pi.PropertyType == typeof(string)) { yield return new KeyValuePair<CDSAttributeAttribute, string>( reference.Value, pi.GetValue(data, null) as string); } else if (pi.PropertyType == typeof(IEnumerable<string>)) { IEnumerable<string> enumerator = pi.GetValue(data, null) as IEnumerable<string>; foreach (string value in enumerator) yield return new KeyValuePair<CDSAttributeAttribute, string>( reference.Value, value); } else if (conv != null && conv.CanConvertFrom(pi.PropertyType)) { yield return new KeyValuePair<CDSAttributeAttribute, string>( reference.Value, conv.ConvertToString(pi.GetValue(data, null))); } } }
/// <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); }
private void SetValueFromConverter(string newValue, Type targetType, TypeConverter converter) { if (!converter.CanConvertFrom(targetType) && string.IsNullOrEmpty(newValue)) { this.Value = null; } else { this.Value = converter.ConvertFrom(newValue); } }
//------------------------------------------------------------------------------------------------- public static object ConvertType(string value, Type type) { if (type.IsEnum) { return(Enum.Parse(type, value)); } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertFrom(value.GetType())) { return(converter.ConvertFrom(value)); } else { return(Convert.ChangeType(value, type)); } }
public static T ConvertType <T>(string value) { if (typeof(T).IsEnum) { return((T)Enum.Parse(typeof(T), value)); } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(typeof(T)); if (converter != null && converter.CanConvertFrom(value.GetType())) { return((T)converter.ConvertFrom(value)); } else { return((T)Convert.ChangeType(value, typeof(T))); } }
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); } }
private static void setPropertyValue(PropertyInfo pi, Type propertyType, object oObj, string value) { if (propertyType == typeof(string)) { pi.SetValue(oObj, value, null); return; } object[] attributes = propertyType.GetCustomAttributes(typeof(System.ComponentModel.TypeConverterAttribute), false); foreach (System.ComponentModel.TypeConverterAttribute converterAttribute in attributes) { System.ComponentModel.TypeConverter converter = (System.ComponentModel.TypeConverter)Activator.CreateInstance(Type.GetType(converterAttribute.ConverterTypeName)); if (converter.CanConvertFrom(value.GetType())) { // good - use the converter to restore the value pi.SetValue(oObj, converter.ConvertFromString(value), null); break; } } }
private static SqlDbType GetDBType(Type theType) { SqlParameter p1 = new SqlParameter(); System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(p1.DbType); if (tc.CanConvertFrom(theType)) { p1.DbType = (DbType)tc.ConvertFrom(theType.Name); } else { //Try brute force try { p1.DbType = (DbType)tc.ConvertFrom(theType.Name); } catch { } //Do Nothing } return(p1.SqlDbType); }
public static object ConvertToType(string value, Type type) { if (type == null) { return(null); } System.ComponentModel.TypeConverter conv = System.ComponentModel.TypeDescriptor.GetConverter(type); if (conv.CanConvertFrom(typeof(string))) { try { return(conv.ConvertFrom(value)); } catch { return(null); } } return(null); }
object ConvertData (TypeConverter c) { if (mime_type == ResXResourceWriter.ByteArraySerializedObjectMimeType) { if (c.CanConvertFrom (typeof (byte []))) return c.ConvertFrom (Convert.FromBase64String (dataString)); } else if (String.IsNullOrEmpty (mime_type)) { if (c.CanConvertFrom (typeof (string))) return c.ConvertFromInvariantString (dataString); } else throw new Exception ("shouldnt get here, invalid mime type"); throw new TypeLoadException ("No converter for this type found"); }
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); }
/// <summary> /// This method retrieves a set of reference attributes from a class. /// </summary> /// <param name="data">The class to examine.</param> /// <param name="conv">A converter function to turn the value in to a string.</param> /// <returns>Returns an enumerable collection of attributes and values.</returns> public static IEnumerable<KeyValuePair<CDSReferenceAttribute, string>> CDSReferencesRetrieve( this IXimuraContent data, TypeConverter conv) { List<KeyValuePair<PropertyInfo, CDSReferenceAttribute>> attrList = AH.GetPropertyAttributes<CDSReferenceAttribute>(data.GetType()); foreach (KeyValuePair<PropertyInfo, CDSReferenceAttribute> reference in attrList) { PropertyInfo pi = reference.Key; if (pi.PropertyType != typeof(string) && (conv == null || !conv.CanConvertFrom(pi.PropertyType))) continue; string value; if (pi.PropertyType == typeof(string)) value = pi.GetValue(data, null) as string; else value = conv.ConvertToString(pi.GetValue(data, null)); yield return new KeyValuePair<CDSReferenceAttribute, string>(reference.Value, value); } }
private void CreateConverter() { // Some properties cannot have type converters. // Such examples are properties that are ConfigurationElement ( derived classes ) // or properties which are user-defined and the user code handles serialization/desirialization so // the property itself is never converted to/from string if (_converter == null) { // Enums are exception. We use our custom converter for all enums if (_type.IsEnum) { _converter = new GenericEnumConverter(_type); } else if (!_type.IsSubclassOf(typeof(ConfigurationElement))) { _converter = TypeDescriptor.GetConverter(_type); if ((_converter == null) || !_converter.CanConvertFrom(typeof(String)) || !_converter.CanConvertTo(typeof(String))) { throw new ConfigurationErrorsException(SR.GetString(SR.No_converter, _name, _type.Name)); } } } }
/// <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)); }
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); }
/// <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); }
/// <summary> /// Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context.</param> /// <param name="sourceType">A <see cref="T:System.Type"></see> that represents the type you want to convert from.</param> /// <returns> /// true if this converter can perform the conversion; otherwise, <c>false</c>. /// </returns> public override bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, Type sourceType) { return((sourceType == typeof(string)) || baseTypeConverter.CanConvertFrom(context, sourceType)); }
/// <summary> /// Creates a new instance of the ConfigurationProperty class. /// </summary> /// <param name="name">The name of the xml entity.</param> /// <param name="type">The type of the xml entity.</param> /// <param name="defaultValue">The default value of the xml entity.</param> /// <param name="converter">The type of the converter to apply.</param> /// <param name="validation">The validator to use.</param> /// <param name="flags">One of the APXmlPropertyOptions enumeration values.</param> /// <param name="description">The description of the xml entity.</param> public APXmlProperty(string name, Type type, object defaultValue, TypeConverter converter, APValidatorBase validation, APXmlPropertyOptions flags, string description) { _name = name; _converter = converter != null ? converter : TypeDescriptor.GetConverter(type); if (defaultValue != null) { if (defaultValue == NoDefaultValue) { switch (Type.GetTypeCode(type)) { case TypeCode.Object: defaultValue = null; break; case TypeCode.String: defaultValue = String.Empty; break; default: defaultValue = Activator.CreateInstance(type); break; } } else { if (!type.IsAssignableFrom(defaultValue.GetType())) { if (!_converter.CanConvertFrom(defaultValue.GetType())) throw new APXmlException(APResource.GetString(APResource.APXml_DefaultValueTypeError, name, type, defaultValue.GetType())); defaultValue = _converter.ConvertFrom(defaultValue); } } } _defaultValue = defaultValue; _flags = flags; _type = type; _validation = validation != null ? validation : new DefaultAPValidator(); _description = description; }
bool SafeCanConvertFrom (Type type, TypeConverter cvt) { try { return cvt.CanConvertFrom (type); } catch (NotImplementedException) { return false; } }
private static bool CanConvertToAndFromString(TypeConverter converter) { return converter.CanConvertFrom(typeof(string)) && converter.CanConvertTo(typeof(string)); }
internal static bool CanConvertToFrom(TypeConverter converter, Type type) { return (converter != null && converter.CanConvertTo(type) && converter.CanConvertFrom(type) && !(converter is ReferenceConverter)); }
public static bool Is <TValue>(this string value) { System.ComponentModel.TypeConverter converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(TValue)); return(((converter != null) && converter.CanConvertFrom(typeof(string))) && converter.IsValid(value)); }
/// <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)); }
public override bool CanConvertFrom(cm.ITypeDescriptorContext context, Type sourceType) { return(etoConverter.CanConvertFrom(sourceType)); }
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; }
private static bool ConvertObjectToTypeInternal(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject) { IDictionary<string, object> dictionary = o as IDictionary<string, object>; if (dictionary != null) { return ConvertDictionaryToObject(dictionary, type, serializer, throwOnError, out convertedObject); } IList list = o as IList; if (list != null) { IList list2; if (ConvertListToObject(list, type, serializer, throwOnError, out list2)) { convertedObject = list2; return true; } convertedObject = null; return false; } if ((type == null) || (o.GetType() == type)) { convertedObject = o; return true; } //TypeDescriptor.GetConverter(type) !!! TypeConverter converter = new TypeConverter(); if (converter.CanConvertFrom(o.GetType())) { try { convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, o); return true; } catch { if (throwOnError) { throw; } convertedObject = null; return false; } } if (converter.CanConvertFrom(typeof(string))) { try { string str; if (o is DateTime) { DateTime time = (DateTime)o; str = time.ToUniversalTime().ToString("u", CultureInfo.InvariantCulture); } else { //ConvertToInvariantString(o); !!! str = converter.ConvertToString(o); } //ConvertFromInvariantString(str); !!! convertedObject = converter.ConvertToString(str); return true; } catch { if (throwOnError) { throw; } convertedObject = null; return false; } } if (type.IsAssignableFrom(o.GetType())) { convertedObject = o; return true; } if (throwOnError) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotConvertObjectToType, new object[] { o.GetType(), type })); } convertedObject = null; return false; }
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); }
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)); }
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); }
private object ConvertType(FieldMap fm, object val) { Check.VerifyNotNull(fm, Error.NullParameter, "fm"); // convert DBNull to system null if (val != null && val.Equals(DBNull.Value)) { val = null; } // perform null handling (NullValue translation) if (val == null && !fm.IsNullAssignable) { Check.Verify(fm.NullValue != null, Error.NullWithNoNullValue, fm.ColumnName, fm.Type); return(fm.NullValue); } else { if (val != null) { Type type = val.GetType(); // trim strings.. otherwise char columns are as wide as their size if (fm.Type == typeof(string) || fm.Type == typeof(Guid)) { if (fm.Type == typeof(Guid)) { if (fm.Size == 16) // binary compressed version { val = Common.TypeConverter.ToGuid((string)val); } else { val = new Guid(val.ToString()); } } else { string strval = (string)val; // size is 0 for variable width columns // assume we should trim all fixed-width columns val = fm.Size > 0 ? strval.TrimEnd() : strval; } } else if (fm.Type == typeof(bool) && type != typeof(bool)) { // if property is boolean but database uses integers we need to convert // the type before updating it val = Convert.ToBoolean(val); } else if (fm.Type.IsEnum && !type.IsEnum) { // check whether enum should be stored as string or numeric value // TODO we should check if enum requires 64-bit conversion // val = fm.HandleEnumAsString ? Enum.Parse( fm.Type, Convert.ToString( val ), true ) : Enum.ToObject( fm.Type, Convert.ToInt32( val ) ); val = Common.TypeConverter.Get(fm.Type, val); } else if (fm.Type == typeof(decimal) && type != typeof(decimal)) { val = Convert.ToDecimal(val, NumberFormatInfo.InvariantInfo); } else if (fm.Type != type) { TypeConverter typeConv = TypeDescriptor.GetConverter(fm.Type); if (typeConv != null && typeConv.CanConvertFrom(type)) { val = typeConv.ConvertFrom(val); } else { // check for the existence of a TypeConverterAttribute for the field/property object[] attrs = fm.MemberInfo.GetCustomAttributes(typeof(TypeConverterAttribute), false); if (attrs.Length == 1) { TypeConverterAttribute tca = (TypeConverterAttribute)attrs[0]; TypeConverter typeConverter = (TypeConverter) Activator.CreateInstance(Type.GetType(tca.ConverterTypeName)); if (typeConverter != null && typeConverter.CanConvertFrom(val.GetType())) { val = typeConverter.ConvertFrom(val); } else { val = Convert.ChangeType(val, fm.Type); } } else { val = Convert.ChangeType(val, fm.Type); } } } } else { // allow NullValue conversion for null strings if (fm.Type == typeof(string) && fm.NullValue != null) { val = fm.NullValue; } } return(val); } }
private bool GetConversionSupported(TypeConverter converter, System.Type conversionType) { return (converter.CanConvertFrom(conversionType) && converter.CanConvertTo(conversionType)); }
/// <summary> /// Returns whether this converter can convert an object of the given type to /// the type of this converter, using the specified context. /// </summary> /// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param> /// <param name="sourceType">A System.Type that represents the type you want to convert from.</param> /// <returns>True if this converter can perform the conversion, False otherwise.</returns> public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { TypeConverter converter = TypeDescriptor.GetConverter(typeof(double)); return(converter.CanConvertFrom(context, sourceType)); }