C# TypeConverter.CanConvertTo方法代码示例

		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++;
			}

		}

 protected internal ModelValueProperty(ModelType declaringType, string name, string label, string helptext, string format, bool isStatic, Type propertyType, TypeConverter converter, bool isList = false, bool isReadOnly = false, bool isPersisted = true, Attribute[] attributes = null, LambdaExpression defaultValue = null)
     : base(declaringType, name, label, helptext, format, isStatic, isList, isReadOnly, isPersisted, attributes)
 {
     this.PropertyType = propertyType;
     this.Converter = converter;
     this.AutoConvert = converter != null && converter.CanConvertTo(typeof(object));
     this.FormatProvider = declaringType.GetFormatProvider(propertyType);
     if (defaultValue != null)
     {
         if (defaultValue.Parameters.Count > 0)
             throw new ArgumentException("Default value expressions cannot have parameters.");
         if (propertyType.IsAssignableFrom(defaultValue.Type))
             throw new ArgumentException("Default value expressions must match the type of the property they are for.");
         this.DefaultValue = defaultValue;
     }
 }

 private bool GetConversionSupported(TypeConverter converter, System.Type conversionType)
 {
     return (converter.CanConvertFrom(conversionType) && converter.CanConvertTo(conversionType));
 }

 private static bool CanConvertToAndFromString(TypeConverter converter)
 {
     return converter.CanConvertFrom(typeof(string)) &&
            converter.CanConvertTo(typeof(string));
 }

		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 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);
		}

 /// <summary>
 /// This method checks whether the specified object can be converted to string.
 /// </summary>
 /// <param name="rawValue">Value to check</param>
 /// <param name="converter">Type converter object</param>
 /// <returns>
 /// True, if the type can be converted to string; otherwise, false;
 /// </returns>
 public static bool CanConvertToString(object rawValue, out TypeConverter converter)
 {
     var valueType = rawValue.GetType();
     converter = TypeDescriptor.GetConverter(valueType);
     return converter != null && converter.CanConvertTo(typeof(String));
 }

        /// <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
            //
//.........这里部分代码省略.........

        /// <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));
        }

 internal static bool CanConvertToFrom(TypeConverter converter, Type type) {
     return (converter != null && converter.CanConvertTo(type) &&
             converter.CanConvertFrom(type) && !(converter is ReferenceConverter));
 }

		bool SafeCanConvertTo (Type type, TypeConverter cvt)
		{
			try {
				return cvt.CanConvertTo (type);
			} catch (NotImplementedException) {
				return false;
			}
		}

 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);
 }

        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));
                    }
                }
            }
        }