WINFROM.PropertyGrid学习小结

最新推荐文章于 2024-11-14 08:46:29 发布
最新推荐文章于 2024-11-14 08:46:29 发布
阅读量146 收藏
点赞数 1
分类专栏： C# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42109102/article/details/121542163
版权 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.ComponentModel.Design.Serialization;
using System.Globalization;
using System.Reflection;
using System.Collections;
using System.ComponentModel.Design;
using System.Drawing.Design;

namespace ClassLibrary1
{
 
    public partial class UserControl2 : UserControl
    {
        public UserControl2()
        {
            InitializeComponent();
            this.BackColor = Color.FromArgb(88, 47, 50);
        }
        [Category("自定义属性"),Description("年龄"),Browsable(true)]
        public int Age { get; set; }
        [Category("自定义属性"),Description("全名"),Browsable(true)]
        public string  FullName { get; set; }
        [Category("自定义属性"), Description("性别"), Browsable(true)]
        public Gender Gender { get; set; }
        [Category("自定义属性"), Description("是否已婚"), Browsable(true)]
        public bool IsMarried { get; set; }
        [Category("自定义属性"), Description("地址，该属性提供简单下拉框"), Browsable(true)]
        [TypeConverter(typeof(AddressValues))]
        public string Address { get; set; }
        PersonalInfo personal = null;
        [Category("自定义属性"), Description("个人信息，该属性是复杂属性"), Browsable(true)]
        public PersonalInfo PersonalInfo
        {
            get
            {
                if (personal==null)
                {
                    return new PersonalInfo("No",0,0,"No");
                }
                else
                {
                    return personal;
                }
            }
            set
            {
                personal = value;
            }
        }

        MyNodeCollection _MyNodeCollection = new MyNodeCollection();
        /// <summary>
        /// 用于测试打开Collection Editor的编辑器窗体
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Editor(typeof(MyCollectionEditor), typeof(UITypeEditor))]//属性编辑器
        [Category("自定义属性"), Description("地址，该属性是集合属性，其中包含复杂属性"), Browsable(true)]
        public MyNodeCollection MyNodeCollection
        {
            get
            {
                return _MyNodeCollection;
            }
            set
            {
                _MyNodeCollection = value;
            }
        }

    }
    public enum Gender
    {
        男,
        女
    }

    public class AddressValues:StringConverter
    {
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        {
            return true;
            return base.GetStandardValuesSupported(context);
        }
        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        {
            return new StandardValuesCollection(new string[] { "上海","苏州","南京","无锡" });
        }

    }
    [TypeConverter(typeof(PersonalInfoConverter))]
    public class PersonalInfo
    {
        public string FullName { get; set; }
        public int Age { get; set; }
        public double Height { get; set; }
        public string WorkType { get; set; }
        //public PersonalInfo() { }
        public PersonalInfo(string fullName, int age, double height, string workType)
        {
            this.FullName = fullName;
            this.Age = age;
            this.Height = height;
            this.WorkType = workType;
        }
    }
    public class PersonalInfoConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
        }
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            return destinationType == typeof(InstanceDescriptor) || base.CanConvertTo(context, destinationType);
        }
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            string text = value as string;
            if (text == null)
            {
                return base.ConvertFrom(context, culture, value);
            }
            string text2 = text.Trim();
            if (text2.Length == 0)
            {
                return null;
            }
            if (culture == null)
            {
                culture = CultureInfo.CurrentCulture;
            }
            char separator = culture.TextInfo.ListSeparator[0];
            string[] array = text2.Split(new char[] { separator }, StringSplitOptions.None);
            //int[] array2 = new int[array.Length];
            //TypeConverter converter = TypeDescriptor.GetConverter(typeof(int));
            //for (int i = 0; i < array2.Length; i++)
            //{
            //    array2[i] = (int)converter.ConvertFromString(context, culture, array[i]);
            //}
            if (array.Length == 4)
            {
                string fullName = array[0];
                int age = int.Parse(array[1]);
                double height = double.Parse(array[2]);
                string worType = array[3];
                var instance = new PersonalInfo(fullName, age, height, worType);
                return instance;

            }
            throw new ArgumentException("111");
        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == null)
            {
                throw new ArgumentNullException("destinationType");
            }
            if (value is PersonalInfo)
            {
                PersonalInfo personal = (PersonalInfo)value;
                if (destinationType == typeof(string))
                {
                    if (culture == null)
                    {
                        culture = CultureInfo.CurrentCulture;
                    }
                    string separator = culture.TextInfo.ListSeparator + " ";
                    TypeConverter converter = TypeDescriptor.GetConverter(typeof(object));
                    string[] value2 = new string[]
                    {
                            converter.ConvertToString(context, culture, personal.FullName),
                            converter.ConvertToString(context, culture, personal.Age),
                            converter.ConvertToString(context,culture,personal.Height),
                            converter.ConvertToString(context,culture,personal.WorkType)
                    };
                    return string.Join(separator, value2);
                }
                if (destinationType == typeof(InstanceDescriptor))
                {
                    ConstructorInfo constructor = typeof(PersonalInfo).GetConstructor(new Type[]
                    {
                    typeof(string),
                    typeof(int),
                    typeof(double),
                    typeof(string)

                    });
                    if (constructor != null)
                    {
                        return new InstanceDescriptor(constructor, new object[]
                        {
                        personal.FullName,
                        personal.Age,
                        personal.Height,
                        personal.WorkType
                        });
                    }
                }


            }
            return base.ConvertTo(context, culture, value, destinationType);
        }
        public override object CreateInstance(ITypeDescriptorContext context, IDictionary propertyValues)
        {
            if (propertyValues == null)
            {
                throw new ArgumentNullException("propertyValues");
            }
            object obj = propertyValues["FullName"];
            object obj2 = propertyValues["Age"];
            object obj3 = propertyValues["Height"];
            object obj4 = propertyValues["WorkType"];
            if (obj == null || obj2 == null || obj3 == null || obj4 == null || !(obj is string) || !(obj2 is int) || !(obj3 is double) || !(obj4 is string))
            {
                throw new ArgumentException("111");
            }
            var instance = new PersonalInfo((string)obj, (int)obj2, (double)obj3, (string)obj4);
            return instance;
        }
        public override bool GetCreateInstanceSupported(ITypeDescriptorContext context)
        {
            return true;
        }
        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
        {

            PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(PersonalInfo), attributes);
            return properties.Sort(PersonalInfoConverter.s_propertySort);

        }
        public override bool GetPropertiesSupported(ITypeDescriptorContext context)
        {
            return true;
        }
        private static readonly string[] s_propertySort = new string[] { "FullName", "Age", "Height", "WorkType" };

    }

    /// <summary>
    /// 自定义CollectionEditor编辑器
    /// </summary>
    public class MyCollectionEditor : CollectionEditor
    {
        public MyCollectionEditor(Type type)
        : base(type)
        { }

        protected override bool CanRemoveInstance(object value)
        {
            return false; ;
        }

        /// <summary>
        /// 限制一次选一个实例
        /// </summary>
        /// <returns></returns>
        protected override bool CanSelectMultipleInstances()
        {
            return false;
        }
        protected override CollectionForm CreateCollectionForm()
        {
            CollectionForm frm = base.CreateCollectionForm();
            frm.AcceptButton.PerformClick();
            FieldInfo fileinfo = frm.GetType().GetField("propertyBrowser", BindingFlags.NonPublic | BindingFlags.Instance);
            if (fileinfo != null)
            {
                (fileinfo.GetValue(frm) as System.Windows.Forms.PropertyGrid).HelpVisible = true;
            }
            frm.Width = 700;
            frm.Height = 600;
            return frm;
        }
        /// <summary>
        /// 指定创建的对象类型
        /// </summary>
        /// <returns></returns>
        protected override Type CreateCollectionItemType()
        {
            return typeof(Employee);
        }
        protected override object CreateInstance(Type itemType)
        {
            //创建一个实例
            //Size o = (Size)itemType.Assembly.CreateInstance(itemType.FullName);
            //o.Width = 25;
            //o.Height = 25;
            Employee o = new Employee();
            //IDesignerHost host = (IDesignerHost)this.GetService(typeof(IDesignerHost));
            //host.Container.Add(o);//重要！自动生成组件的设计时代码！

            //或者：
            //this.Context.Container.Add(o);//重要！自动生成组件的设计时代码！

            return o;
        }
        protected override void DestroyInstance(object instance)
        {
            base.DestroyInstance(instance);//重要！自动删除组件的设计时代码！
        }

        //protected override Type[] CreateNewItemTypes()
        //{
        //    return new Type[]
        //    {
        //      typeof(Panel),
        //      typeof(Button),
        //      typeof(TextBox)
        //    };
        //}
        protected override string GetDisplayText(object value)
        {

            Employee item = new Employee();
            item = (Employee)value;
            return base.GetDisplayText(string.Format("{0}", item.Name));
        }

        protected override object[] GetItems(object editValue)
        {
            MyNodeCollection myNodeCollection = (MyNodeCollection)editValue;

            return myNodeCollection.ToArry();
        }
    }

    /// <summary>
    /// 自定义BaseCollection对象集合，实现IList接口
    /// 如Object Collection Editor窗体的Add/Delete钮不可用是因为没有实现IList接口
    /// </summary>
    public class MyNodeCollection : BaseCollection, IList
    {
        private ArrayList _innerList;

        public MyNodeCollection()
        {
            _innerList = new ArrayList();
        }

        protected override ArrayList List
        {
            get
            {
                return (ArrayList)_innerList;
            }
        }
        public override int Count
        {
            get { return _innerList.Count; }
        }



        #region IList Members

        public int Add(object value)
        {
            return this.List.Add(value);
        }

        public void Clear()
        {
            this.List.Clear();
        }

        public bool Contains(object value)
        {
            return this.List.Contains(value);
        }

        public int IndexOf(object value)
        {
            return this.List.IndexOf(value);
        }

        public void Insert(int index, object value)
        {
            this.List.Insert(index, value);
        }

        public bool IsFixedSize
        {
            get { return this.List.IsFixedSize; }
        }

        public void Remove(object value)
        {
            this.List.Remove(value);
        }

        public void RemoveAt(int index)
        {
            this.List.RemoveAt(index);
        }

        public object this[int index]
        {
            get
            {
                return List[index];
            }
            set
            {
                List[index] = value;
            }
        }
        public object[] ToArry()
        {
            return _innerList.ToArray();
        }
        #endregion
    }

    public class Employee
    {
        [Category("基本属性")]
        [DisplayName("员工姓名")]
        [Description("员工姓名")]
        public string Name { get; set; }


        [Category("基本属性")]
        [DisplayName("姓别")]
        [Description("姓别")]
        public EnumGender Gender { get; set; }
        [Category("基本属性")]
        [DisplayName("尺寸")]
        [Description("尺寸")]

        public Size InnerSize { get; set; }
        [Category("基本属性")]
        [DisplayName("人员信息")]
        [Description("人员信息")]
        public PersonalInfo PersonalInfo { get; set; } = new PersonalInfo("No", 0, 0, "No");


    }

    public enum EnumGender
    {
        男 = 0,
        女,
    };

}

效果如下图：
在这里插入图片描述

WinFrom.exe
06-18
C#应急条码记录，条码扫描防止重复，设置单独删除文件信息
左菜单栏的winfrom.zip
12-18
标题提到的"左菜单栏的winfrom.zip"是一个压缩包，其中包含了实现这一功能的源代码和项目文件。以下是关于如何在WinForms中创建左侧菜单栏的相关知识点： 1. **Windows Forms 用户控件(User Control)**：在WinForms...
这几天的工作用到了Winform的PropertyGrid，说说心得~
weixin_34143774的博客
01-07 1046
      PropertyGrid的功能不用我多说了，看名字就可以知道个大概，在这里就谈谈它的一些功能使用。 假设目前有一个PropertyGrid控件PropTableColumn,那么进行属性绑定只需要一句话： this.PropTableColumn.SelectedObject = ... ; 其中...表示需要进行绑定的对象，PropertyGrid使用的广泛性也主要...
PropertyGrid 下拉式和弹出编辑框的实现
weixin_42103688的博客
09-23 977
PropertyGrid 下拉式和弹出式编辑框的实现
WinForm窗体PropertyGrid控件的使用
weixin_30493401的博客
09-11 227
　　使用过 Microsoft Visual Basic 或 Microsoft Visual Studio .NET的朋友，一定使用过属性浏览器来浏览、查看或编辑一个或多个对象的属性。.NET 框架 PropertyGrid 控件是 Visual Studio .NET 属性浏览器的核心。PropertyGrid 控件显示对象或类型的属性，并主要通过使用反射（在运行时提供类型信息的技术）来检索项...
C#中的PropertyGrid控件在WinForm调试中的妙用
abc2221的博客
05-14 292
PropertyGrid，提供用于浏览对象属性的用户界面。在WinForm设计界面，点击某一个控件，选择“属性”页，可以看到控件的各个属性与对应的值，而用于展示这些信息的，就是PropertyGrid控件。 我们在进行WinForm程序设计与调试的时候，当需要修改控件的属性，如文本颜色、背景颜色、文本内容时，我们只能停止调试，重新设置属性再调试；有时候还要获取控件无法直接显示的属性，如...
Winform PropertyGrid使用方法
热门推荐
熊老大的专栏
03-28 1万+
原文连接 先来转一个基础的，源自msdn http://www.microsoft.com/taiwan/msdn/library/2002/Jul-2002/article/usingpropgrid.htm 摘要： 本文旨在帮助您了解 Microsoft .NET 框架中的 PropertyGrid 控件，以及如何针对您的应用程序自定义该控件。 适用于：      M
winform之propertyGrid控件简单使用方法
qq_26374395的博客
06-30 4060
winform之propertyGrid控件简单使用方法winform之propertyGrid控件简单使用方法常用的Attribute[CategoryAttribute("设置")][DisplayNameAttribute("Name1")][ReadOnlyAttribute("true")][DescriptionAttribute("以毫秒表示的文本重复率。")][BrowsableAttribute(true)][DefaultPropertyAttribute(“PKG”)]自定义属性类与P
Winform PropertyGrid控件
路过
01-17 1528
Winform PropertyGrid控件
sqllite-winfrom.zip
08-14
标题 "sqllite-winfrom.zip" 提供了一个关于SQLite数据库集成到Windows Forms应用程序的场景。这个压缩包包含了一些关键文件，表明它是一个.NET Framework（可能是ASP.NET）项目，用于演示或教学如何在C#环境下使用...
使用PropertyGrid加载并显示XML文件
12-21
在C#2019中，将XML结点动态映射为属性集，然后使用PropertyGrid加载并显示。支持父结点的名称自动映射为Category(目录).
Winform 属性编辑器 propertyGrid示例 下拉列表框
02-01
在Windows Forms（Winform）开发中，`PropertyGrid`控件是一个非常实用的工具，它允许用户以图形化的方式查看和编辑对象的属性。在某些场景下，我们可能需要为`PropertyGrid`添加自定义的功能，例如展示下拉列表框...
C# PropertyGrid控件应用心得
如影随形
11-22 5311
<br />目录<br />PropertyGrid 控件简介 <br />创建 PropertyGrid 控件 <br />何处使用 PropertyGrid 控件 <br />选择对象 <br />自定义 PropertyGrid 控件 <br />显示复杂属性 <br />为属性提供自定义 UI <br /><br />PropertyGrid 控件简介 <br />如果您使用过 Microsoft? Visual Basic? 或 Microsoft Visual Studio .NET，那么您一定
冗余连接 代随写法的C#版本
qq_74014730的博客
11-11 895
卡码网108 与 力扣684题 总体来说一摸一样。与1971寻找图中是否存在路径很相似因为初学 学习的代随的写法 就一直延续了没有用里扣的写法108. 冗余连接。
C# 操作Rabbitmq
qq_36437991的博客
11-11 308
C# 操作Rabbitmq
浅谈C#之单线程流式适配器
最新发布
a876106354的博客
11-14 471
在C#中，单线程流式适配器通常用于处理流式数据，如网络通信或文件操作中的连续数据流。这些数据流可能是有序的，并且数据包之间可能会发生粘连，即没有明确的分界线，导致粘包和半包问题。解决这些问题的关键在于识别数据包的标识和顺序。在更复杂的应用中，可能需要自定义流式单线程适配器来处理特定的协议或数据格式。这通常涉及到解析数据头和数据体，以及处理数据的顺序和完整性。// 记录初始游标位置，防止本次无法解析时，回退游标。// 此操作实际上有两个作用，// 1.填充header。
每日一题——第一百二十一题
weixin_45778846的博客
11-07 1479
【代码】每日一题——第一百二十一题。
windows C#-创建记录类型(上)
苏洛的博客
11-12 675
记录是使用基于值的相等性的类型。 C# 10 添加了 record structs，以便你可以将记录定义为值类型。 两个记录类型的变量在它们的类型和值都相同时，它们是相等的。 两个类类型的变量如果引用的对象属于同一类类型并且引用相同的对象，则这两个变量是相等的。 基于值的相等性意味着可能需要的记录类型中的其他功能。 声明 record 而不是 class 时，编译器将生成许多这些成员。 编译器针对 record struct 类型生成这些相同的方法。
C#中break和continue的区别？
xioayanran123的博客
11-11 243
• 在for循环中，continue会导致跳过循环体中continue之后的语句，并直接跳到更新表达式（通常是i++）和条件判断部分。• 在while和do-while循环中，continue会导致跳过循环体中continue之后的语句，并直接回到条件判断部分。• 剩下的奇数（1、3、7、9）中，只有1和3被打印出来，因为7和9在i等于5之后，而循环已经在i等于5时终止了。在C#编程语言中，break和continue是两个用于控制循环流程的关键字，但它们的作用和用途有所不同。continue关键字。
c# winfrom 打印.btw
09-18
在C# Windows Forms应用程序中，打印文件通常是通过`PrintDocument`类来实现的。这个类提供了一个处理打印任务的标准模型，包括设置纸张、选择打印机等步骤。以下是简单的步骤： 1. 创建`PrintDocument`对象： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值