C#如何在派生类中不显示父类的一些属性以及TypeDescriptor使用

public SonClass：FatherClass

{

定义属性

。。。。

}

Type thisType = typeof(SonClass);
方法一：

PropertyInfo[] pis = thisType.BaseType.GetProperties();//thisType.BaseType就是FatherClass
foreach (PropertyInfo p in pps)
{
properties.Remove(p.Name);
}

方法二：

PropertyInfo[] pis = thisType.GetProperties();
foreach (PropertyInfo p in pps)
{
if (p.DeclaringType != thisType)
properties.Remove(p.Name);
}
}

方法三：

/// <summary>
/// 支持展现属性的类型转换器
/// </summary>
/// <remarks></remarks>
[System.Runtime.InteropServices.ComVisible(false)]
[System.Reflection.Obfuscation(Exclude = true, ApplyToMembers = true)]
public class TypeConverterSupportProperties : System.ComponentModel.TypeConverter
{
/// <summary>
/// 支持获得属性
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
return true;
}
/// <summary>
/// 获得属性
/// </summary>
/// <param name="context"></param>
/// <param name="value"></param>
/// <param name="attributes"></param>
/// <returns></returns>
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
PropertyDescriptorCollection ps = TypeDescriptor.GetProperties(value, attributes);
return ps;
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(string))
{
return false;
}
return base.CanConvertTo(context, destinationType);
}
}

方法四：直接把下面的代码添加到需要的类里面即可（本代码演示了ClassAAA 继承了 Label, ICustomTypeDescriptor（接口），紫色的代码即为要添加的）

using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Windows.Forms;
using System.Reflection;
namespace WindowsFormsApplication2
{
public class ClassAAA : Label, ICustomTypeDescriptor
{
private bool me = false;
public bool IsMe
{
get
{
return me;
}
set
{
this.me = value;
}
}
public int Code
{
get
{
return this.GetHashCode();
}
}
#region ICustomTypeDescriptor 显式接口定义
AttributeCollection ICustomTypeDescriptor.GetAttributes()
{
return TypeDescriptor.GetAttributes(this, true);
}
string ICustomTypeDescriptor.GetClassName()
{
return TypeDescriptor.GetClassName(this, true);
}
string ICustomTypeDescriptor.GetComponentName()
{
return TypeDescriptor.GetComponentName(this, true);
}
TypeConverter ICustomTypeDescriptor.GetConverter()
{
return TypeDescriptor.GetConverter(this, true);
}
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
{
return TypeDescriptor.GetDefaultEvent(this, true);
}
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
{
return null;
}
object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
{
return TypeDescriptor.GetEditor(this, editorBaseType, true);
}
EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
{
return TypeDescriptor.GetEvents(this, true);
}
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
{
return TypeDescriptor.GetEvents(this, attributes, true);
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
{
return ((ICustomTypeDescriptor)this).GetProperties(new Attribute[0]);
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
{
ArrayList props = new ArrayList();
Type thisType = typeof(OneClass);
PropertyInfo[] pis = thisType.GetProperties();
foreach (PropertyInfo p in pis)
{
if (p.DeclaringType == thisType)
{
PropertyStub psd = new PropertyStub(p, attributes);
props.Add(psd);
}
}
PropertyDescriptor[] propArray =
(PropertyDescriptor[])props.ToArray(typeof(PropertyDescriptor));
return new PropertyDescriptorCollection(propArray);
}
object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
{
return this;
}
#endregion
#region PropertyStub 定义
private class PropertyStub : PropertyDescriptor
{
PropertyInfo info;
public PropertyStub(PropertyInfo propertyInfo, Attribute[] attrs) :
base(propertyInfo.Name, attrs)
{
this.info = propertyInfo;
}
public override Type ComponentType
{
get { return this.info.ReflectedType; }
}
public override bool IsReadOnly
{
get { return this.info.CanWrite == false; }
}
public override Type PropertyType
{
get { return this.info.PropertyType; }
}
public override bool CanResetValue(object component)
{
return false;
}
public override object GetValue(object component)
{
Console.WriteLine("GetValue: " + component.GetHashCode());
return this.info.GetValue(component, null);
}
public override void ResetValue(object component)
{
}
public override void SetValue(object component, object value)
{
Console.WriteLine("SetValue: " + component.GetHashCode());
this.info.SetValue(component, value, null);
}
public override bool ShouldSerializeValue(object component)
{
return false;
}
}
#endregion
}
}

TypeDescriptor 类

提供有关组件属性 (Attribute) 的信息，如组件的属性 (Attribute)、属性 (Property) 和事件。无法继承此类。

命名空间:System.ComponentModel
程序集:System（在 system.dll 中）

语法

public sealed class TypeDescriptor

备注

.NET Framework 提供了两种访问某类型的元数据的方式：通过 System.Reflection 命名空间中提供的反射 API，以及通过 TypeDescriptor类。反射是可用于所有类型的通用机制，因为它是基于根 Object 类的 GetType 方法建立的。反射为某个类型返回的信息不可扩展，因为编译了目标类型后就不能对其进行修改。有关更多信息，请参见反射中的主题。

相反，TypeDescriptor 是组件的可扩展检查机制：即实现 IComponent 接口的那些类。与反射不同的是，它并不检查方法。通过目标组件的Site 中提供的几种服务，可以动态扩展 TypeDescriptor。下表显示这些服务。

服务名	说明
IExtenderProvider	启用其他类（如 ToolTip），以便为组件提供额外的属性 (Property)。
ITypeDescriptorFilterService	启用其他对象，以便修改由组件公开的标准元数据。
ICustomTypeDescriptor	启用一个类，以便完全且动态地指定其自身的元数据，进而替换 TypeDescriptor 的标准检查机制。

TypeDescriptor 提供的扩展性允许组件的设计时表示形式不同于其实际的运行时表示形式，从而使 TypeDescriptor 对于生成设计时基础结构十分有用。

TypeDescriptor 中的所有方法都是 static 的。不能创建此类的实例，也不能继承此类。

可以通过两种不同的方式设置属性 (Property) 和事件值：在组件类中指定它们，或在设计时对它们进行更改。由于可以通过两种方式设置这些值，因此，TypeDescriptor 的重载方法采用两种不同类型的参数：类类型或对象实例。

当要访问 TypeDescriptor 信息并且您具有对象的实例时，应使用调用组件的方法。只有当您不具有对象的实例时，才能使用调用类类型的方法。

为了提高速度，将由 TypeDescriptor 缓存属性和事件。通常，它们在对象的生存期内保持不变。但是，扩展程序提供程序和设计器可以更改对象的属性集。如果是这种情况，则必须调用 Refresh 方法来更新缓存。