C# PropertyGrid封装类（VS2010）

   

功能简介：

1、支持下拉、打开文件、文本输入、点击项可显示描述内容。

以下业务代码则是调用封装类。

Category ：属性类

DisplayName：名称

Descriptor：描述内容

Editor：编辑器

        private PropertyManage _pmc=new PropertyManage();
        /// <summary>
        /// 绑定PropertyGrid
        /// </summary>
        /// <returns></returns>
        public Object GetPropertyObject()
        {  
            #region 方案配置
            Property pp = new Property("SchemeName", "test.xml", false, true);
            pp.Category = "方案配置";
            pp.DisplayName = "方案";
            pp.Editor = new PropertyGridFileEditor();
            _pmc.Add(pp);
            #endregion

            #region 表计规格
            pp = new Property("MeterType", "1S");
            pp.Category = "表计规格";
            pp.DisplayName = "表计类型";
            string[] s = new string[] { "1S", "2S", "3S" };
            pp.Converter = new DropDownListConverter(s);
            _pmc.Add(pp);

            pp = new Property("RatedVolt","220");
            pp.Category = "表计规格";
            pp.DisplayName = "额定电压";
            pp.Descriptor = "V";
            _pmc.Add(pp);

            pp = new Property("RatedCurrent", "0");
            pp.Category = "表计规格";
            pp.DisplayName = "额定电流";
            pp.Descriptor = "A";
            _pmc.Add(pp);

            pp = new Property("RatedFreq", "60");
            pp.Category = "表计规格";
            pp.DisplayName = "额定频率";
            pp.Descriptor = "Hz";
            _pmc.Add(pp);

            pp = new Property("Phase","三相四线");
            pp.Category = "表计规格";
            pp.DisplayName = "接线方式";
            s=new string[]{"三相四线","三相三相","单相"};
            pp.Converter = new DropDownListConverter(s);
            _pmc.Add(pp);
            #endregion 
            return _pmc;
        }

//最后PropertyGrid控件调用
PropertyGrid.SelectedObject = GetPropertyObject();

以下封装代码可直接拷贝，提示错误则是未引用相关命名控件，右键解析自动添加。(PS：修改他人成果)

region 封装操作PropertyGrid属性方法

    //属性管理类
    public class PropertyManage : CollectionBase, ICustomTypeDescriptor
    {
        public void Add(Property value)
        {
            int flag = -1;
            if (value != null)
            {
                if (base.List.Count > 0)
                {
                    IList<Property> mList = new List<Property>();
                    for (int i = 0; i < base.List.Count; i++)
                    {
                        Property p = base.List[i] as Property;
                        if (value.Name == p.Name)
                        {
                            flag = i;
                        }
                        mList.Add(p);
                    }
                    if (flag == -1)
                    {
                        mList.Add(value);
                    }
                    base.List.Clear();
                    foreach (Property p in mList)
                    {
                        base.List.Add(p);
                    }
                }
                else
                {
                    base.List.Add(value);
                }
            }
        }
        public void Remove(Property value)
        {
            if (value != null && base.List.Count > 0)
                base.List.Remove(value);
        }
        public Property this[int index]
        {
            get
            {
                return (Property)base.List[index];
            }
            set
            {
                base.List[index] = (Property)value;
            }
        }
        #region ICustomTypeDescriptor 成员
        public AttributeCollection GetAttributes()
        {
            return TypeDescriptor.GetAttributes(this, true);
        }
        public string GetClassName()
        {
            return TypeDescriptor.GetClassName(this, true);
        }
        public string GetComponentName()
        {
            return TypeDescriptor.GetComponentName(this, true);
        }
        public TypeConverter GetConverter()
        {
            return TypeDescriptor.GetConverter(this, true);
        }
        public EventDescriptor GetDefaultEvent()
        {
            return TypeDescriptor.GetDefaultEvent(this, true);
        }
        public PropertyDescriptor GetDefaultProperty()
        {
            return TypeDescriptor.GetDefaultProperty(this, true);
        }
        public object GetEditor(Type editorBaseType)
        {
            return TypeDescriptor.GetEditor(this, editorBaseType, true);
        }
        public EventDescriptorCollection GetEvents(Attribute[] attributes)
        {
            return TypeDescriptor.GetEvents(this, attributes, true);
        }
        public EventDescriptorCollection GetEvents()
        {
            return TypeDescriptor.GetEvents(this, true);
        }
        public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
        {
            PropertyDescriptor[] newProps = new PropertyDescriptor[this.Count];
            for (int i = 0; i < this.Count; i++)
            {
                Property prop = (Property)this[i];
                newProps[i] = new CustomPropertyDescriptor(ref prop, attributes);
            }
            return new PropertyDescriptorCollection(newProps);
        }
        public PropertyDescriptorCollection GetProperties()
        {
            return TypeDescriptor.GetProperties(this, true);
        }
        public object GetPropertyOwner(PropertyDescriptor pd)
        {
            return this;
        }
        #endregion
    }
    //属性类  
    public class Property
    {
        private string _name = string.Empty;
        private object _value = null;
        private bool _readonly = false;
        private bool _visible = true;
        private string _category = string.Empty;
        private string _descriptor = string.Empty;
        TypeConverter _converter = null;
        object _editor = null;
        private string _displayname = string.Empty;
        public Property(string sName, object sValue)
        {
            this._name = sName;
            this._value = sValue;
        }
        public Property(string sName, object sValue, bool sReadonly, bool sVisible)
        {
            this._name = sName;
            this._value = sValue;
            this._readonly = sReadonly;
            this._visible = sVisible;
        }
        public string Name  //获得属性名  
        {
            get{return _name;}
            set{_name = value;}
        }
        public string DisplayName   //属性显示名称  
        {
            get{return _displayname;}
            set{_displayname = value;}
        }
        public TypeConverter Converter  //类型转换器，制作下拉列表时需要用到  
        {
            get{return _converter;}
            set{_converter = value;}
        }
        public string Category  //属性所属类别  
        {
            get{return _category;}
            set{_category = value;}
        }
        public object Value  //属性值  
        {
            get{return _value;}
            set{_value = value;}
        }
        public string Descriptor
        {
            get { return _descriptor; }
            set { _descriptor = value; }
        }
        public bool ReadOnly  //是否为只读属性  
        {
            get{return _readonly;}
            set{_readonly = value;}
        }
        public bool Visible  //是否可见  
        {
            get{return _visible;}
            set{_visible = value;}
        }
        public virtual object Editor   //属性编辑器  
        {
            get{ return _editor; }
            set{_editor = value;}
        }
    }
    //属性描述类
    public class CustomPropertyDescriptor : PropertyDescriptor
    {
        Property m_Property;
        public CustomPropertyDescriptor(ref Property myProperty, Attribute[] attrs): base(myProperty.Name, attrs)
        {
            m_Property = myProperty;
        }
        #region PropertyDescriptor 重写方法
        public override bool CanResetValue(object component)
        {
            return false;
        }
        public override Type ComponentType
        {
            get{return null;}
        }
        public override object GetValue(object component)
        {
            return m_Property.Value;
        }
        public override string Description
        {
            get{ return m_Property.Descriptor;}
        }
        public override string Category
        {
            get{return m_Property.Category;}
        }
        public override string DisplayName
        {
            get{return m_Property.DisplayName != "" ? m_Property.DisplayName : m_Property.Name;}
        }
        public override bool IsReadOnly
        {
            get{return m_Property.ReadOnly;}
        }
        public override void ResetValue(object component)
        {
            //Have to implement  
        }
        public override bool ShouldSerializeValue(object component)
        {
            return false;
        }
        public override void SetValue(object component, object value)
        {
            m_Property.Value = value;
        }
        public override TypeConverter Converter
        {
            get{return m_Property.Converter;}
        }
        public override Type PropertyType
        {
            get { return m_Property.Value.GetType(); }
        }
        public override object GetEditor(Type editorBaseType)
        {
            return m_Property.Editor == null ? base.GetEditor(editorBaseType) : m_Property.Editor;
        }
        #endregion
    }
    //文件对话框编辑类
    public class PropertyGridFileEditor : UITypeEditor  
    {  
  
        public override UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)  
        {  
            return UITypeEditorEditStyle.Modal;  
        }  
  
        public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)  
        {  
            IWindowsFormsEditorService edSvc=(IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));  
            if (edSvc != null)  
            {  
                // 可以打开任何特定的对话框  
                OpenFileDialog dialog = new OpenFileDialog();  
                dialog.AddExtension = false;  
                if (dialog.ShowDialog().Equals(DialogResult.OK))  
                {  
                    return dialog.FileName;  
                }  
            }  
            return value;  
        }  
  
    }
    //文件下拉转换类
    public class DropDownListConverter : StringConverter
    {
        object[] m_Objects;
        public DropDownListConverter(object[] objects)
        {
            m_Objects = objects;
        }
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        {
            return true;
        }
        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)  
        {  
            return true;
        }
        public override
        System.ComponentModel.TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        {
            return new StandardValuesCollection(m_Objects);//可以直接在内部定义一个数组，但并不建议这样做，这样对于下拉框的灵活             //性有很大影响  
        }
    }
    #endregion