The Labs \ Source Viewer \ SSCLI \ System.ComponentModel \ TypeConverter

  1. //------------------------------------------------------------------------------
  2. // <copyright file="TypeConverter.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. /*
  16. */
  17. namespace System.ComponentModel
  18. {
  19.     using Microsoft.Win32;
  20.     using System.Collections;
  21.     using System.ComponentModel.Design.Serialization;
  22.     using System.Diagnostics;
  23.     using System.Diagnostics.CodeAnalysis;
  24.     using System.Globalization;
  25.     using System.Runtime.InteropServices;
  26.     using System.Runtime.Remoting;
  27.     using System.Runtime.Serialization.Formatters;
  28.     using System.Security.Permissions;
  29.    
  30.     /// <devdoc>
  31.     /// <para>Converts the value of an object into a different data type.</para>
  32.     /// </devdoc>
  33.     [HostProtection(SharedState = true)]
  34.     [System.Runtime.InteropServices.ComVisible(true)]
  35.     public class TypeConverter
  36.     {
  37.        
  38.         /// <devdoc>
  39.         /// <para>Gets a value indicating whether this converter can convert an object in the
  40.         /// given source type to the native type of the converter.</para>
  41.         /// </devdoc>
  42.         public bool CanConvertFrom(Type sourceType)
  43.         {
  44.             return CanConvertFrom(null, sourceType);
  45.         }
  46.        
  47.         /// <devdoc>
  48.         /// <para>Gets a value indicating whether this converter can
  49.         /// convert an object in the given source type to the native type of the converter
  50.         /// using the context.</para>
  51.         /// </devdoc>
  52.         public virtual bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
  53.         {
  54.             if (sourceType == typeof(InstanceDescriptor)) {
  55.                 return true;
  56.             }
  57.             return false;
  58.         }
  59.        
  60.         /// <devdoc>
  61.         /// <para>
  62.         /// Gets a value
  63.         /// indicating whether this converter can convert an object to the given destination
  64.         /// type.
  65.         /// </para>
  66.         /// </devdoc>
  67.         public bool CanConvertTo(Type destinationType)
  68.         {
  69.             return CanConvertTo(null, destinationType);
  70.         }
  71.        
  72.         /// <devdoc>
  73.         /// <para>Gets a value indicating whether this converter can
  74.         /// convert an object to the given destination type using the context.</para>
  75.         /// </devdoc>
  76.         public virtual bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
  77.         {
  78.             return (destinationType == typeof(string));
  79.         }
  80.        
  81.         /// <devdoc>
  82.         /// <para>Converts the given value
  83.         /// to the converter's native type.</para>
  84.         /// </devdoc>
  85.         public object ConvertFrom(object value)
  86.         {
  87.             return ConvertFrom(null, CultureInfo.CurrentCulture, value);
  88.         }
  89.        
  90.         /// <devdoc>
  91.         /// <para>Converts the given object to the converter's native type.</para>
  92.         /// </devdoc>
  93.         public virtual object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
  94.         {
  95.             InstanceDescriptor id = value as InstanceDescriptor;
  96.             if (id != null) {
  97.                 return id.Invoke();
  98.             }
  99.             throw GetConvertFromException(value);
  100.         }
  101.        
  102.         /// <devdoc>
  103.         /// Converts the given string to the converter's native type using the invariant culture.
  104.         /// </devdoc>
  105.         [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
  106.         public object ConvertFromInvariantString(string text)
  107.         {
  108.             return ConvertFromString(null, CultureInfo.InvariantCulture, text);
  109.         }
  110.        
  111.         /// <devdoc>
  112.         /// Converts the given string to the converter's native type using the invariant culture.
  113.         /// </devdoc>
  114.         public object ConvertFromInvariantString(ITypeDescriptorContext context, string text)
  115.         {
  116.             return ConvertFromString(context, CultureInfo.InvariantCulture, text);
  117.         }
  118.        
  119.         /// <devdoc>
  120.         /// <para>Converts the specified text into an object.</para>
  121.         /// </devdoc>
  122.         public object ConvertFromString(string text)
  123.         {
  124.             return ConvertFrom(null, null, text);
  125.         }
  126.        
  127.         /// <devdoc>
  128.         /// <para>Converts the specified text into an object.</para>
  129.         /// </devdoc>
  130.         public object ConvertFromString(ITypeDescriptorContext context, string text)
  131.         {
  132.             return ConvertFrom(context, CultureInfo.CurrentCulture, text);
  133.         }
  134.        
  135.         /// <devdoc>
  136.         /// <para>Converts the specified text into an object.</para>
  137.         /// </devdoc>
  138.         public object ConvertFromString(ITypeDescriptorContext context, CultureInfo culture, string text)
  139.         {
  140.             return ConvertFrom(context, culture, text);
  141.         }
  142.        
  143.         /// <devdoc>
  144.         /// <para>Converts the given
  145.         /// value object to the specified destination type using the arguments.</para>
  146.         /// </devdoc>
  147.         public object ConvertTo(object value, Type destinationType)
  148.         {
  149.             return ConvertTo(null, null, value, destinationType);
  150.         }
  151.        
  152.         /// <devdoc>
  153.         /// <para>Converts the given value object to
  154.         /// the specified destination type using the specified context and arguments.</para>
  155.         /// </devdoc>
  156.         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
  157.         // keep CultureInfo
  158.         public virtual object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
  159.         {
  160.             if (destinationType == null) {
  161.                 throw new ArgumentNullException("destinationType");
  162.             }
  163.            
  164.             if (destinationType == typeof(string)) {
  165.                 if (value == null) {
  166.                     return String.Empty;
  167.                 }
  168.                
  169.                 if (culture != null && culture != CultureInfo.CurrentCulture) {
  170.                     IFormattable formattable = value as IFormattable;
  171.                     if (formattable != null) {
  172.                             /* format = */                            /* formatProvider = */                        return formattable.ToString(null, culture);
  173.                     }
  174.                 }
  175.                 return value.ToString();
  176.             }
  177.             throw GetConvertToException(value, destinationType);
  178.         }
  179.        
  180.         /// <devdoc>
  181.         /// <para>Converts the specified value to a culture-invariant string representation.</para>
  182.         /// </devdoc>
  183.         public string ConvertToInvariantString(object value)
  184.         {
  185.             return ConvertToString(null, CultureInfo.InvariantCulture, value);
  186.         }
  187.        
  188.         /// <devdoc>
  189.         /// <para>Converts the specified value to a culture-invariant string representation.</para>
  190.         /// </devdoc>
  191.         public string ConvertToInvariantString(ITypeDescriptorContext context, object value)
  192.         {
  193.             return ConvertToString(context, CultureInfo.InvariantCulture, value);
  194.         }
  195.        
  196.         /// <devdoc>
  197.         /// <para>Converts the specified value to a string representation.</para>
  198.         /// </devdoc>
  199.         [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")]
  200.         public string ConvertToString(object value)
  201.         {
  202.             return (string)ConvertTo(null, CultureInfo.CurrentCulture, value, typeof(string));
  203.         }
  204.        
  205.         /// <devdoc>
  206.         /// <para>Converts the specified value to a string representation.</para>
  207.         /// </devdoc>
  208.         public string ConvertToString(ITypeDescriptorContext context, object value)
  209.         {
  210.             return (string)ConvertTo(context, CultureInfo.CurrentCulture, value, typeof(string));
  211.         }
  212.        
  213.         /// <devdoc>
  214.         /// <para>Converts the specified value to a string representation.</para>
  215.         /// </devdoc>
  216.         public string ConvertToString(ITypeDescriptorContext context, CultureInfo culture, object value)
  217.         {
  218.             return (string)ConvertTo(context, culture, value, typeof(string));
  219.         }
  220.        
  221.         /// <devdoc>
  222.         /// <para>Re-creates an <see cref='System.Object'/> given a set of property values for the object.</para>
  223.         /// </devdoc>
  224.         public object CreateInstance(IDictionary propertyValues)
  225.         {
  226.             return CreateInstance(null, propertyValues);
  227.         }
  228.        
  229.         /// <devdoc>
  230.         /// <para>Re-creates an <see cref='System.Object'/> given a set of property values for the
  231.         /// object.</para>
  232.         /// </devdoc>
  233.         public virtual object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
  234.         {
  235.             return null;
  236.         }
  237.        
  238.         /// <devdoc>
  239.         /// <para>
  240.         /// Gets a suitable exception to throw when a conversion cannot
  241.         /// be performed.
  242.         /// </para>
  243.         /// </devdoc>
  244.         protected Exception GetConvertFromException(object value)
  245.         {
  246.             string valueTypeName;
  247.            
  248.             if (value == null) {
  249.                 valueTypeName = SR.GetString(SR.ToStringNull);
  250.             }
  251.             else {
  252.                 valueTypeName = value.GetType().FullName;
  253.             }
  254.            
  255.             throw new NotSupportedException(SR.GetString(SR.ConvertFromException, GetType().Name, valueTypeName));
  256.         }
  257.        
  258.         /// <devdoc>
  259.         /// <para>Retrieves a suitable exception to throw when a conversion cannot
  260.         /// be performed.</para>
  261.         /// </devdoc>
  262.         protected Exception GetConvertToException(object value, Type destinationType)
  263.         {
  264.             string valueTypeName;
  265.            
  266.             if (value == null) {
  267.                 valueTypeName = SR.GetString(SR.ToStringNull);
  268.             }
  269.             else {
  270.                 valueTypeName = value.GetType().FullName;
  271.             }
  272.            
  273.             throw new NotSupportedException(SR.GetString(SR.ConvertToException, GetType().Name, valueTypeName, destinationType.FullName));
  274.         }
  275.        
  276.         /// <devdoc>
  277.         /// <para>Gets a value indicating whether changing a value on this
  278.         /// object requires a call to <see cref='System.ComponentModel.TypeConverter.CreateInstance'/>
  279.         /// to create a new value.</para>
  280.         /// </devdoc>
  281.         public bool GetCreateInstanceSupported()
  282.         {
  283.             return GetCreateInstanceSupported(null);
  284.         }
  285.        
  286.         /// <devdoc>
  287.         /// <para>Gets a value indicating whether changing a value on this object requires a
  288.         /// call to <see cref='System.ComponentModel.TypeConverter.CreateInstance'/> to create a new value,
  289.         /// using the specified context.</para>
  290.         /// </devdoc>
  291.         public virtual bool GetCreateInstanceSupported(ITypeDescriptorContext context)
  292.         {
  293.             return false;
  294.         }
  295.        
  296.         /// <devdoc>
  297.         /// <para>Gets a collection of properties for the type of array specified by the value
  298.         /// parameter.</para>
  299.         /// </devdoc>
  300.         public PropertyDescriptorCollection GetProperties(object value)
  301.         {
  302.             return GetProperties(null, value);
  303.         }
  304.        
  305.         /// <devdoc>
  306.         /// <para>Gets a collection of
  307.         /// properties for the type of array specified by the value parameter using the specified
  308.         /// context.</para>
  309.         /// </devdoc>
  310.         public PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value)
  311.         {
  312.             return GetProperties(context, value, new Attribute[] {BrowsableAttribute.Yes});
  313.         }
  314.        
  315.         /// <devdoc>
  316.         /// <para>Gets a collection of properties for
  317.         /// the type of array specified by the value parameter using the specified context and
  318.         /// attributes.</para>
  319.         /// </devdoc>
  320.         public virtual PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
  321.         {
  322.             return null;
  323.         }
  324.        
  325.         /// <devdoc>
  326.         /// <para>
  327.         /// Gets a value indicating whether this object supports properties.
  328.         /// </para>
  329.         /// </devdoc>
  330.         public bool GetPropertiesSupported()
  331.         {
  332.             return GetPropertiesSupported(null);
  333.         }
  334.        
  335.         /// <devdoc>
  336.         /// <para>Gets a value indicating
  337.         /// whether this object supports properties using the
  338.         /// specified context.</para>
  339.         /// </devdoc>
  340.         public virtual bool GetPropertiesSupported(ITypeDescriptorContext context)
  341.         {
  342.             return false;
  343.         }
  344.        
  345.         /// <devdoc>
  346.         /// <para> Gets a collection of standard values for the data type this type
  347.         /// converter is designed for.</para>
  348.         /// </devdoc>
  349.         public ICollection GetStandardValues()
  350.         {
  351.             return GetStandardValues(null);
  352.         }
  353.        
  354.         /// <devdoc>
  355.         /// <para>Gets a collection of standard values for the data type this type converter is
  356.         /// designed for.</para>
  357.         /// </devdoc>
  358.         public virtual StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
  359.         {
  360.             return null;
  361.         }
  362.        
  363.         /// <devdoc>
  364.         /// <para>Gets a value indicating whether the collection of standard values returned from
  365.         /// <see cref='System.ComponentModel.TypeConverter.GetStandardValues'/> is an exclusive list. </para>
  366.         /// </devdoc>
  367.         public bool GetStandardValuesExclusive()
  368.         {
  369.             return GetStandardValuesExclusive(null);
  370.         }
  371.        
  372.         /// <devdoc>
  373.         /// <para>Gets a value indicating whether the collection of standard values returned from
  374.         /// <see cref='System.ComponentModel.TypeConverter.GetStandardValues'/> is an exclusive
  375.         /// list of possible values, using the specified context.</para>
  376.         /// </devdoc>
  377.         public virtual bool GetStandardValuesExclusive(ITypeDescriptorContext context)
  378.         {
  379.             return false;
  380.         }
  381.        
  382.         /// <devdoc>
  383.         /// <para>
  384.         /// Gets a value indicating whether this object supports a standard set of values
  385.         /// that can be picked from a list.
  386.         /// </para>
  387.         /// </devdoc>
  388.         public bool GetStandardValuesSupported()
  389.         {
  390.             return GetStandardValuesSupported(null);
  391.         }
  392.        
  393.         /// <devdoc>
  394.         /// <para>Gets a value indicating
  395.         /// whether this object
  396.         /// supports a standard set of values that can be picked
  397.         /// from a list using the specified context.</para>
  398.         /// </devdoc>
  399.         public virtual bool GetStandardValuesSupported(ITypeDescriptorContext context)
  400.         {
  401.             return false;
  402.         }
  403.        
  404.         /// <devdoc>
  405.         /// <para>
  406.         /// Gets
  407.         /// a value indicating whether the given value object is valid for this type.
  408.         /// </para>
  409.         /// </devdoc>
  410.         public bool IsValid(object value)
  411.         {
  412.             return IsValid(null, value);
  413.         }
  414.        
  415.         /// <devdoc>
  416.         /// <para>Gets
  417.         /// a value indicating whether the given value object is valid for this type.</para>
  418.         /// </devdoc>
  419.         public virtual bool IsValid(ITypeDescriptorContext context, object value)
  420.         {
  421.             return true;
  422.         }
  423.        
  424.         /// <devdoc>
  425.         /// <para>Sorts a collection of properties.</para>
  426.         /// </devdoc>
  427.         protected PropertyDescriptorCollection SortProperties(PropertyDescriptorCollection props, string[] names)
  428.         {
  429.             props.Sort(names);
  430.             return props;
  431.         }
  432.        
  433.         /// <devdoc>
  434.         /// <para>
  435.         /// An <see langword='abstract '/>
  436.         /// class that provides
  437.         /// properties for objects that do not have
  438.         /// properties.
  439.         /// </para>
  440.         /// </devdoc>
  441.         protected abstract class SimplePropertyDescriptor : PropertyDescriptor
  442.         {
  443.             private Type componentType;
  444.             private Type propertyType;
  445.            
  446.            
  447.             /// <devdoc>
  448.             /// <para>
  449.             /// Initializes a new instance of the <see cref='System.ComponentModel.TypeConverter.SimplePropertyDescriptor'/>
  450.             /// class.
  451.             /// </para>
  452.             /// </devdoc>
  453.             protected SimplePropertyDescriptor(Type componentType, string name, Type propertyType) : this(componentType, name, propertyType, new Attribute[0])
  454.             {
  455.             }
  456.            
  457.             /// <devdoc>
  458.             /// <para>
  459.             /// Initializes a new instance of the <see cref='System.ComponentModel.TypeConverter.SimplePropertyDescriptor'/> class.
  460.             /// </para>
  461.             /// </devdoc>
  462.             protected SimplePropertyDescriptor(Type componentType, string name, Type propertyType, Attribute[] attributes) : base(name, attributes)
  463.             {
  464.                 this.componentType = componentType;
  465.                 this.propertyType = propertyType;
  466.             }
  467.            
  468.             /// <devdoc>
  469.             /// <para>
  470.             /// Gets the type of the component this property description
  471.             /// is bound to.
  472.             /// </para>
  473.             /// </devdoc>
  474.             public override Type ComponentType {
  475.                 get { return componentType; }
  476.             }
  477.            
  478.             /// <devdoc>
  479.             /// <para>
  480.             /// Gets a
  481.             /// value indicating whether this property is read-only.
  482.             /// </para>
  483.             /// </devdoc>
  484.             public override bool IsReadOnly {
  485.                 get { return Attributes.Contains(ReadOnlyAttribute.Yes); }
  486.             }
  487.            
  488.             /// <devdoc>
  489.             /// <para>
  490.             /// Gets the type of the property.
  491.             /// </para>
  492.             /// </devdoc>
  493.             public override Type PropertyType {
  494.                 get { return propertyType; }
  495.             }
  496.            
  497.             /// <devdoc>
  498.             /// <para>Gets a value indicating whether resetting the component
  499.             /// will change the value of the component.</para>
  500.             /// </devdoc>
  501.             public override bool CanResetValue(object component)
  502.             {
  503.                 DefaultValueAttribute attr = (DefaultValueAttribute)Attributes[typeof(DefaultValueAttribute)];
  504.                 if (attr == null) {
  505.                     return false;
  506.                 }
  507.                 return (attr.Value.Equals(GetValue(component)));
  508.             }
  509.            
  510.             /// <devdoc>
  511.             /// <para>Resets the value for this property
  512.             /// of the component.</para>
  513.             /// </devdoc>
  514.             public override void ResetValue(object component)
  515.             {
  516.                 DefaultValueAttribute attr = (DefaultValueAttribute)Attributes[typeof(DefaultValueAttribute)];
  517.                 if (attr != null) {
  518.                     SetValue(component, attr.Value);
  519.                 }
  520.             }
  521.            
  522.             /// <devdoc>
  523.             /// <para>Gets a value
  524.             /// indicating whether the value of this property needs to be persisted.</para>
  525.             /// </devdoc>
  526.             public override bool ShouldSerializeValue(object component)
  527.             {
  528.                 return false;
  529.             }
  530.         }
  531.        
  532.         /// <devdoc>
  533.         /// <para>Represents a collection of values.</para>
  534.         /// </devdoc>
  535.         public class StandardValuesCollection : ICollection
  536.         {
  537.             private ICollection values;
  538.             private Array valueArray;
  539.            
  540.             /// <devdoc>
  541.             /// <para>
  542.             /// Initializes a new instance of the <see cref='System.ComponentModel.TypeConverter.StandardValuesCollection'/>
  543.             /// class.
  544.             /// </para>
  545.             /// </devdoc>
  546.             public StandardValuesCollection(ICollection values)
  547.             {
  548.                 if (values == null) {
  549.                     values = new object[0];
  550.                 }
  551.                
  552.                 Array a = values as Array;
  553.                 if (a != null) {
  554.                     valueArray = a;
  555.                 }
  556.                
  557.                 this.values = values;
  558.             }
  559.            
  560.             /// <devdoc>
  561.             /// <para>
  562.             /// Gets the number of objects in the collection.
  563.             /// </para>
  564.             /// </devdoc>
  565.             public int Count {
  566.                 get {
  567.                     if (valueArray != null) {
  568.                         return valueArray.Length;
  569.                     }
  570.                     else {
  571.                         return values.Count;
  572.                     }
  573.                 }
  574.             }
  575.            
  576.             /// <devdoc>
  577.             /// <para>Gets the object at the specified index number.</para>
  578.             /// </devdoc>
  579.             public object this[int index]
  580.             {
  581.                 get {
  582.                     if (valueArray != null) {
  583.                         return valueArray.GetValue(index);
  584.                     }
  585.                     IList list = values as IList;
  586.                     if (list != null) {
  587.                         return list[index];
  588.                     }
  589.                     // No other choice but to enumerate the collection.
  590.                     //
  591.                     valueArray = new object[values.Count];
  592.                     values.CopyTo(valueArray, 0);
  593.                     return valueArray.GetValue(index);
  594.                 }
  595.             }
  596.            
  597.             /// <devdoc>
  598.             /// <para>Copies the contents of this collection to an array.</para>
  599.             /// </devdoc>
  600.             public void CopyTo(Array array, int index)
  601.             {
  602.                 values.CopyTo(array, index);
  603.             }
  604.            
  605.             /// <devdoc>
  606.             /// <para>
  607.             /// Gets an enumerator for this collection.
  608.             /// </para>
  609.             /// </devdoc>
  610.             public IEnumerator GetEnumerator()
  611.             {
  612.                 return values.GetEnumerator();
  613.             }
  614.            
  615.             /// <internalonly/>
  616.             /// <devdoc>
  617.             /// Retrieves the count of objects in the collection.
  618.             /// </devdoc>
  619.             int ICollection.Count {
  620.                 get { return Count; }
  621.             }
  622.            
  623.             /// <internalonly/>
  624.             /// <devdoc>
  625.             /// Determines if this collection is synchronized.
  626.             /// The ValidatorCollection is not synchronized for
  627.             /// speed. Also, since it is read-only, there is
  628.             /// no need to synchronize it.
  629.             /// </devdoc>
  630.             bool ICollection.IsSynchronized {
  631.                 get { return false; }
  632.             }
  633.            
  634.             /// <internalonly/>
  635.             /// <devdoc>
  636.             /// Retrieves the synchronization root for this
  637.             /// collection. Because we are not synchronized,
  638.             /// this returns null.
  639.             /// </devdoc>
  640.             object ICollection.SyncRoot {
  641.                 get { return null; }
  642.             }
  643.            
  644.             /// <internalonly/>
  645.             /// <devdoc>
  646.             /// Copies the contents of this collection to an array.
  647.             /// </devdoc>
  648.             void ICollection.CopyTo(Array array, int index)
  649.             {
  650.                 CopyTo(array, index);
  651.             }
  652.            
  653.             /// <internalonly/>
  654.             /// <devdoc>
  655.             /// Retrieves a new enumerator that can be used to
  656.             /// iterate over the values in this collection.
  657.             /// </devdoc>
  658.             IEnumerator IEnumerable.GetEnumerator()
  659.             {
  660.                 return GetEnumerator();
  661.             }
  662.         }
  663.     }
  664. }

Developer Fusion