当前位置：首页 > 软件开发 > .NET > ASP.NET

.net WinForm用户控件开发--(5)用户控件复杂属性设置

来源：岁月联盟编辑：exp 时间：2012-08-01

这一节，大家共同学习下，用户控件的自定义的复杂的属性设置，我们这里自定义一个用户控件和自定义一个属性。

本节重点:

1.怎样定义复杂属性

2.复杂属性和基本类型相互转换

1.第一步，先来自定义一个类，代码如下

[csharp]
/// <summary>
   /// 自定义属性类
   /// </summary>
   public class CustomAttri
   {

       public CustomAttri(int width, int height)
       {
           _width = width;
           _height = height;
       }

       public CustomAttri()
       {

       }
       private int _width;
       private int _height;

       /// <summary>
       /// 宽度
       /// </summary>
       public int Width
       {
           get
           { return _width; }
           set
           {
               _width = value;
           }
       }

       /// <summary>
       /// 高度
       /// </summary>
       public int Height
       {
           get
           {
               return _height;
           }
           set
           {
               _height = value;
           }
       }
   }

/// <summary>
    /// 自定义属性类
    /// </summary>
    public class CustomAttri
    {

        public CustomAttri(int width, int height)
        {
            _width = width;
            _height = height;
        }

        public CustomAttri()
        {

        }
        private int _width;
        private int _height;

        /// <summary>
        /// 宽度
        /// </summary>
        public int Width
        {
            get
            { return _width; }
            set
            {
                _width = value;
            }
        }

        /// <summary>
        /// 高度
        /// </summary>
        public int Height
        {
            get
            {
                return _height;
            }
            set
            {
                _height = value;
            }
        }
    }
然后自定义一个控件，并且定义一属性SecondSize，代码如下

[csharp]
public partial class UCPanel : Control
    {
        public UCPanel()
        {
            InitializeComponent();
        }

      private CustomAttri _sSize=new CustomAttri(20,30);;
        /// <summary>
        /// 定义自定义属性
        /// </summary>
        [Description("第二尺寸")]
        [Category("尺寸")]
        public CustomAttri SecondSize
        {
          get
          {
            return _sSize;
          }
         set
            {
              _sSize=value;
            }
        }
    }

public partial class UCPanel : Control
    {
        public UCPanel()
        {
            InitializeComponent();
        }

      private CustomAttri _sSize=new CustomAttri(20,30);;
        /// <summary>
        /// 定义自定义属性
        /// </summary>
        [Description("第二尺寸")]
        [Category("尺寸")]
        public CustomAttri SecondSize
        {
          get
          {
            return _sSize;
          }
         set
            {
              _sSize=value;
            }
        }
    }

此时编译项目，然后把用户控件拖到窗体上，就可以在属性设计器中看到此属性，但是此时属性是只读的，不能设置值。

效果图如下：

2. 接下来，我们实现让用户可以自己设置属性的值，并把用户输入的值进行转换。

如果想要把用户输入的值转换为我们自定义的类型，需要继承TypeConverter 类，并实现其方法。

转换器代码如下:

[csharp]
/// <summary>
   /// 自定义类型转换器
   /// </summary>
   public class CustomAttriConverter:TypeConverter
   {
       /// <summary>
       /// 表示是否允许将给定类型的对象转换为自定义类型
       /// </summary>
       /// <param name="context">当前上下文对象</param>
       /// <param name="sourceType">给定的类型</param>
       /// <returns></returns>
       public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
       {
           //如果给定的类型为字符串，可以转换为自定义类型
           if (sourceType==typeof(string))
           {
               return true;
           }
           return base.CanConvertFrom(context, sourceType);
       }

       /// <summary>
       /// 表示是否允许将自定义类型转换为指定的类型
       /// </summary>
       /// <param name="context">当前上下文</param>
       /// <param name="destinationType">指定的类型</param>
       /// <returns></returns>
       public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
       {
           //如果目标类型是字符串，允许将自定义类型转换为字符串
           if (destinationType==typeof(string))
           {
               return true;
           }
           return base.CanConvertTo(context, destinationType);
       }

       /// <summary>
       /// 将指定类型转换为自定义类型
       /// </summary>
       /// <param name="context">当前上下文信息</param>
       /// <param name="culture">区域信息</param>
       /// <param name="value">指定类型</param>
       /// <returns></returns>
       public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
       {
           if (value is string)
           {
               string[] sizeArr = ((string)value).Split(',');//将输入的字符串以逗号进行分割
               CustomAttri ca = new CustomAttri();
               ca.Width=Convert.ToInt16(sizeArr[0]);
               ca.Height=Convert.ToInt16(sizeArr[1]);
               return ca;
           }
           return base.ConvertFrom(context, culture, value);
       }

       /// <summary>
       /// 将自定义类型转换为指定类型
       /// </summary>
       /// <param name="context">当前上下文</param>
       /// <param name="culture">区域</param>
       /// <param name="value"></param>
       /// <param name="destinationType">指定类型</param>
       /// <returns></returns>
       public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
       {
           //如果要转换为自定义类型
           if (destinationType==typeof(string))
           {
               if (value is CustomAttri)
               {
                   CustomAttri ca = (CustomAttri)value;
                   return ca.Width.ToString() + "," + ca.Height.ToString();
               }
           }
           return base.ConvertTo(context, culture, value, destinationType);
       }

   }

/// <summary>
    /// 自定义类型转换器
    /// </summary>
    public class CustomAttriConverter:TypeConverter
    {
        /// <summary>
        /// 表示是否允许将给定类型的对象转换为自定义类型
        /// </summary>
        /// <param name="context">当前上下文对象</param>
        /// <param name="sourceType">给定的类型</param>
        /// <returns></returns>
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            //如果给定的类型为字符串，可以转换为自定义类型
            if (sourceType==typeof(string))
            {
                return true;
            }
            return base.CanConvertFrom(context, sourceType);
        }

        /// <summary>
        /// 表示是否允许将自定义类型转换为指定的类型
        /// </summary>
        /// <param name="context">当前上下文</param>
        /// <param name="destinationType">指定的类型</param>
        /// <returns></returns>
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            //如果目标类型是字符串，允许将自定义类型转换为字符串
            if (destinationType==typeof(string))
            {
                return true;
            }
            return base.CanConvertTo(context, destinationType);
        }

        /// <summary>
        /// 将指定类型转换为自定义类型
        /// </summary>
        /// <param name="context">当前上下文信息</param>
        /// <param name="culture">区域信息</param>
        /// <param name="value">指定类型</param>
        /// <returns></returns>
        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            if (value is string)
            {
                string[] sizeArr = ((string)value).Split(',');//将输入的字符串以逗号进行分割
                CustomAttri ca = new CustomAttri();
                ca.Width=Convert.ToInt16(sizeArr[0]);
                ca.Height=Convert.ToInt16(sizeArr[1]);
                return ca;
            }
            return base.ConvertFrom(context, culture, value);
        }

        /// <summary>
        /// 将自定义类型转换为指定类型
        /// </summary>
        /// <param name="context">当前上下文</param>
        /// <param name="culture">区域</param>
        /// <param name="value"></param>
        /// <param name="destinationType">指定类型</param>
        /// <returns></returns>
        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
        {
            //如果要转换为自定义类型
            if (destinationType==typeof(string))
            {
                if (value is CustomAttri)
                {
                    CustomAttri ca = (CustomAttri)value;
                    return ca.Width.ToString() + "," + ca.Height.ToString();
                }
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }

}
然后把该转换器标记在自定义属性上，这样在窗体上，就可以为该用户控件的属性设置值了

[csharp]
[Description("第二尺寸")]
    [Category("尺寸")]
    [TypeConverter(typeof(CustomAttriConverter))]
    public CustomAttri SecondSize
    {
      get
      {
        return _sSize;
      }
     set
        {
          _sSize=value;
        }
    }

    [Description("第二尺寸")]
        [Category("尺寸")]
        [TypeConverter(typeof(CustomAttriConverter))]
        public CustomAttri SecondSize
        {
          get
          {
            return _sSize;
          }
         set
            {
              _sSize=value;
            }
        }
    效果图:

3.子属性的实现

上面代码虽然实现了可以给自定义属性设置值，但是字属性不能显示出来，如果想实现把子属性显示出来，需要重载以下方法

[csharp]
/// <summary>
      /// 返回此对象是否支持属性。
      /// </summary>
      /// <param name="context"></param>
      /// <returns></returns>
      public override bool GetPropertiesSupported(ITypeDescriptorContext context)
      {
          return true;
      }

      public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
      {
          //return base.GetProperties(context, value, attributes);
          return TypeDescriptor.GetProperties(typeof(CustomAttri), attributes);
      }

/// <summary>
        /// 返回此对象是否支持属性。
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override bool GetPropertiesSupported(ITypeDescriptorContext context)
        {
            return true;
        }

        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
        {
            //return base.GetProperties(context, value, attributes);
            return TypeDescriptor.GetProperties(typeof(CustomAttri), attributes);
        }
效果图：