public class Scope
    {
        private Int32 _min;
        private Int32 _max;

        public Scope()
        {
        }

public Scope(Int32 min, Int32 max)
        {
            _min = min;
            _max = max;
        }

        [Browsable(true)]
        public Int32 Min
        {
            get
            {
                return _min;
            }
            set
            {
                _min = value;
            }
        }

        [Browsable(true)]
        public Int32 Max
        {
            get
            {
                return _max;
            }
            set
            {
                _max = value;
            }
           
        }
}

       添加完屬性后，build控件工程，然后在測試的工程里選中添加的控件，然后在屬性瀏覽器里觀察它的屬性，發現Scope屬性是灰的，不能編輯。前一篇文章提到了，在屬性瀏覽器里可以編輯的屬性都是有類型轉換器的，而.NET框架為基本的類型和常用的類型都提供了默認的類型轉換器。接下來我們為Scope類添加一個類型轉換器，以便這個屬性能夠被編輯，而且也可以在源代碼文件里自動生成相應的代碼。下面是類型轉換器的代碼：
      

public class ScopeConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof(String)) return true;

            return base.CanConvertFrom(context, sourceType);
        }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            if (destinationType == typeof(String)) return true;

            if (destinationType == typeof(InstanceDescriptor)) return true;

            return base.CanConvertTo(context, destinationType);
        }

        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            String result = "";
            if (destinationType == typeof(String))
            {
                Scope scope = (Scope)value;
                result = scope.Min.ToString()+"," + scope.Max.ToString();
                return result;

            }

            if (destinationType == typeof(InstanceDescriptor))
            {
                ConstructorInfo ci = typeof(Scope).GetConstructor(new Type[] {typeof(Int32),typeof(Int32) });
                Scope scope = (Scope)value;
                return new InstanceDescriptor(ci, new object[] { scope.Min,scope.Max });
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }

        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            if (value is string)
            {
                String[] v = ((String)value).Split(',');
                if (v.GetLength(0) != 2)
                {
                    throw new ArgumentException("Invalid parameter format");
                }

                Scope csf = new Scope();
                csf.Min = Convert.ToInt32(v[0]);
                csf.Max = Convert.ToInt32(v[1]);
                return csf;
            }
            return base.ConvertFrom(context, culture, value);
        }
    }

           

    [TypeConverter(typeof(ScopeConverter))]
    public class Scope