深度解析 TypeConverter & TypeConverterAttribute （一）

前言
    我们在开发复杂控件的时候不可避免的碰到类型转换TypeConverter，微软给我们提供了很多转换类如ArrayConverter，BaseNumberConverter，BooleanConverter（MSDN上更多：ms-help://MS.MSDNQTR.v80.en/MS.MSDN.v80/MS.NETDEVFX.v20.en/cpref3/html/N_System_ComponentModel.htm）等直接或间接的继承了TypeConverter类。我们在类型转换的时候经常用到这些类。然而我们如何编写自定义的TypeConverter类呢，又怎么样在复杂控件中使用呢。

TypeConverter Class
    TypeConverter类就是将一种类型（object，可以说是任何类型）转换到另一种类型（一般为string），或者将另一种类型转换回来。所有继承TypeConverter类型的都必须实现4个方法：（这里以另一种类型string为例）
    CanConverterTo 有两个重载方法，
             TypeConverter.CanConvertTo (Type)
             TypeConverter.CanConvertTo (ITypeDescriptorContext, Type)
       都有一个Type参数（要转换成什么类型）,例如我们设计的要转换成string，在方法体里面判断这个参数的Type如果是string，则返回true，否则返回           false
    ConverterTo 也有两重载，
             TypeConverter.ConvertTo (Object, Type)
             TypeConverter.ConvertTo (ITypeDescriptorContext, CultureInfo, Object, Type)
       都有Object和Type参数，将Object转成Type类型的Object，返回Type类型的Object。
  下面类似的两个方法，不过方向相反，是从其他类型装换回来。
    CanConverterFrom 重载，
             TypeConverter.CanConvertFrom (Type)
             TypeConverter.CanConvertFrom (ITypeDescriptorContext, Type)
       在方法体里面判断参数Type是不是能转换回来的类型，例如string类型，如果是返回true，否则返回false。
    ConverterFrom 重载，
            TypeConverter.ConvertFrom (Object)
            TypeConverter.ConvertFrom (ITypeDescriptorContext, CultureInfo, Object)
       在方法体里面判断参数Object的类型是不是能转换回来的类型，例如string类型，如果是返回转换回来的类型。
      
    举例说明，以GPS经纬度位置为例，经纬度位置GPSLocation包括复杂属性经度Longitude和纬度Latitude。现我们根据其一属性Longitude类写个LongtitudeTypeConverter类。
    首先我们得有个Longtitude类吧。

public   class  Longitude
{
     private   int  _Degrees;
     private   int  _Minutes;
     private   int  _Seconds;
     private  LongitudeDirection _Direction;

     ///   <summary>
     ///  度数
     ///   </summary>
     public   int  Degrees { }

     ///   <summary>
     ///  分度
     ///   </summary>
     public   int  Minutes { }

     ///   <summary>
     ///  秒读
     ///   </summary>
     public   int  Seconds { }

     ///   <summary>
     ///  方向
     ///   </summary>
     public  LongitudeDirection Direction
    {
    }
}

有了个这个类，我们怎样将其转换到string类或其他类呢（这里假设string类）例如“24W3'4”形式，也许你会说重写ToString（）方法不就行了，似乎可行，但如果转换成其他类呢，又从其他类转换回来呢，怎么办。还有在复杂控件中Designer设计中又该怎么办。（在复杂控件的应用稍后介绍）
    自然，这样我们是不是要写个转换类比较好呢，这个类必须直接或这间接继承TypeConverter类。

     class  LongitudeTypeConverter : TypeConverter
    {
        
    }

然后重载实现上面说的四个方法，现在我要Longitude类转换到string类型

CanConverterFrom
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof(string))
                return true;
            else
                return base.CanConvertFrom(context, sourceType);
        }

 

CanConverterTo
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if ((destinationType == typeof(string)) |
                (destinationType == typeof(InstanceDescriptor)))
                return true;
            else
                return base.CanConvertTo(context, destinationType);
        }

 

ConvertTo
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            // check that the value we got passed on is of type Longitude
            if (value != null)
                if (!(value is Longitude))
                    throw new Exception(WrongType);

            // convert to a string
            if (destinationType == typeof(string))
            {
                // no value so we return an empty string
                if (value == null)
                    return string.Empty;

                // strongly typed
                Longitude LongValue = value as Longitude;

                // get the two type converters to use
                TypeConverter IntConverter = TypeDescriptor.GetConverter(typeof(int));
                TypeConverter EnumConverter = TypeDescriptor.GetConverter(typeof(LongitudeDirection));

                // convert to a string and return
                return IntConverter.ConvertToString(context, culture, LongValue.Degrees) +
                       EnumConverter.ConvertToString(context, culture, LongValue.Direction).Substring(0, 1) +
                       IntConverter.ConvertToString(context, culture, LongValue.Minutes) + MinutesUnit +
                       IntConverter.ConvertToString(context, culture, LongValue.Seconds) + SecondsUnit;
            }

            // convert to a instance descriptor
            if (destinationType == typeof(InstanceDescriptor))
            { 
                // no value so we return no instance descriptor
                if (value == null)
                    return null;

                // strongly typed
                Longitude LongValue = value as Longitude;

                // used to descripe the constructor
                MemberInfo Member = null;
                object[] Arguments = null;

                // get the constructor for the type
                Member = typeof(Longitude).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(int), typeof(LongitudeDirection) });

                // create the arguments to pass along
                Arguments = new object[] { LongValue.Degrees, LongValue.Minutes, LongValue.Seconds, LongValue.Direction };

                // return the instance descriptor
                if (Member != null)
                    return new InstanceDescriptor(Member, Arguments);
                else
                    return null;
            }

            // call the base converter
            return base.ConvertTo(context, culture, value, destinationType);
        }

 

ConvertFrom
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            // no value so we return a new Longitude instance
            if (value == null)
                return new Longitude();

            // convert from a string
            if (value is string)
            {
                // get strongly typed value
                string StringValue = value as string;

                // empty string so we return a new Longitude instance
                if (StringValue.Length <= 0)
                    return new Longitude();

                // get the position of the West longitude separator
                int DirectionPos = StringValue.IndexOf(LongitudeDirection.West.ToString().Substring(0, 1));
                LongitudeDirection Direction = LongitudeDirection.West;

                // if not found get the position of the East longitude separator
                if (DirectionPos == -1)
                {
                    DirectionPos = StringValue.IndexOf(LongitudeDirection.East.ToString().Substring(0, 1));
                    Direction = LongitudeDirection.East;
                }

                // get the minutes and seconds characters
                int MinutesPos = StringValue.IndexOf(MinutesUnit);
                int SecondsPos = StringValue.IndexOf(SecondsUnit);

                // no minutes present
                if (MinutesPos == -1)
                    throw new Exception(MinutesMissing);

                // no seconds present
                if (SecondsPos == -1)
                    throw new Exception(SecondsMissing);

                // no minutes present
                if (DirectionPos == -1)
                    throw new Exception(DirectionMissing);

                // no degrees present
                if (DirectionPos == 0)
                    throw new Exception(DegreesMissing);

                // get the type converters we need
                TypeConverter IntConverter = TypeDescriptor.GetConverter(typeof(int));

                // get the degrees, minutes and seconds value
                int Degrees = (int)IntConverter.ConvertFromString(context, culture, StringValue.Substring(0, DirectionPos));
                int Minutes = (int)IntConverter.ConvertFromString(context, culture, StringValue.Substring(DirectionPos + 1, MinutesPos - DirectionPos - 1));
                int Seconds = (int)IntConverter.ConvertFromString(context, culture, StringValue.Substring(MinutesPos + 1, SecondsPos - MinutesPos - 1));

                // create a new Longitude instance with these values and return it
                return new Longitude(Degrees, Minutes, Seconds, Direction);
            }

            // otherwise call the base converter
            else
                return base.ConvertFrom(context, culture, value);
        }

有了这个转换类LongitudeTypeConverter，该怎么使用呢。其实很简单就是使用我们上面实现的四个方法，

  class  Test
    {
         public   static   void  Main( string [] args)
        {
             // 将Longitude类转换到string类型
            Longitude longitude  =   new  Longitude( 10 , 11 , 12 ,LongitudeDirection.East);
            LongitudeTypeConverter converter  =   new  LongitudeTypeConverter();

             string  strLongitude = "" ;
             if  (converter.CanConvertTo( typeof ( string )))
            {
                strLongitude  =  ( string )converter.ConvertTo(longitude,  typeof ( string ));
            }
            System.Console.WriteLine(strLongitude);

             // 将string还原回Longitude类
            Longitude longitude1  =   new  Longitude();
             if  (converter.CanConvertFrom( typeof ( string )))
            {
                longitude1  =  (Longitude)converter.ConvertFrom(strLongitude);
            }
            System.Console.WriteLine(longitude1.Degrees);
            System.Console.WriteLine(longitude1.Direction);
            System.Console.WriteLine(longitude1.Minutes);
            System.Console.WriteLine(longitude1.Seconds);
        }
    }

输出结果是
10E11'12''
10
East
11
12
从结果中我们可以看到实现了我们预期的效果。
这些在一般代码里面可以用到，但从转换的结果中我们可以联想，web页面设计的两种模式（设计模式，源代码模式），在源代码模式我们显示的是string，但在设计模式我们显示控件的外观，这里就关系到TypeConverter类了，当然还有TypeConverterAtrribute。
下面就要说下这个TypeConverterAtrribute了。
待续...