将DesignerSerializationVisibility的默认值设置为hidden

Is there a way to set the a default value for the attribute DesignerSerializationVisibility for all the properties of a given class?

有没有办法为给定类的所有属性设置属性DesignerSerializationVisibility的默认值？

In practice, a way to switch the default behavior of black-listing the properties with a white-list approach.

实际上，这是一种使用白名单方法切换黑名单属性的默认行为的方法。

Thanks

谢谢

1 个解决方案

#1

My preferance

You can provide default values for properties in constructor and decorate them using suitable DefaultValue attribute, then the designer will serialize them only if the value of them is different than default value.

您可以在构造函数中为属性提供默认值，并使用合适的DefaultValue属性对它们进行装饰，然后设计器仅在它们的值不同于默认值时才序列化它们。

Also if you need to make them invisible at design-time, you can simply decorate them using Browsable(false) then they will not be shown at design time.

此外，如果您需要在设计时使它们不可见，您可以使用Browsable（false）简单地装饰它们，然后它们将不会在设计时显示。

Also you can check DesignMode in property setter to prevent setting a value for the property at design time and make it a run-time property.

您还可以在属性设置器中检查DesignMode，以防止在设计时为属性设置值并使其成为运行时属性。

I also answer your question which you need to Not serialize properties that doesn't have DesignerSerializationVisibility attribute.

我还回答了您需要的问题，而不是序列化没有DesignerSerializationVisibility属性的属性。

At least the approach will introduce a really useful feature to you which you may find helpful in the future.

至少这种方法会为您介绍一个非常有用的功能，您可能会发现它有用。

Not serialize properties that doesn't have DesignerSerializationVisibility attribute

A way to switch the default behavior of blacklisting the properties with a white list approach.

一种使用白名单方法切换将属性列入黑名单的默认行为的方法。

As an option you can create a custom type descriptor for your component and using custom property descriptors which it returns, tell the designer to don't serialize properties that doesn't have DesignerSerializationVisibility.

作为选项，您可以为组件创建自定义类型描述符并使用它返回的自定义属性描述符，告诉设计者不要序列化没有DesignerSerializationVisibility的属性。

This way when you want the designer serialize a property you should decorate it with DesignerSerializationVisibility attribute with visible as value.

这样，当您希望设计器序列化属性时，您应该使用带有visible值的DesignerSerializationVisibility属性来装饰它。

Implemetaion

Implemetaion

The designer ask the PropertyDescriptor of a property to decide to serialize the property. If the ShouldSerialize method of the descriptor returns true it serializes the property, otherwise it doesn't serialize the property.

设计者要求属性的PropertyDescriptor决定序列化属性。如果描述符的ShouldSerialize方法返回true，则序列化该属性，否则它不会序列化该属性。

To change this behavior you should override that method. To make the designer to use your property descriptor, you should register a custom TypeDescriptionProvider for your class. The provider should provide a custom TypeDescriptor for your class. The custom type descriptor should return a list of your new PropertyDescriptor which you override that method.

要更改此行为，您应该覆盖该方法。要使设计器使用属性描述符，您应该为您的类注册自定义TypeDescriptionProvider。提供程序应为您的类提供自定义TypeDescriptor。自定义类型描述符应返回您重写该方法的新PropertyDescriptor的列表。

Important Note: To test the implementations, you should restart the visual studio.

重要说明：要测试实现，您应该重新启动visual studio。

TypeDescriptionProvider

TypeDescriptionProvider

Here we create a custom type description provider for our component. Then we will register the provider for our component.

在这里，我们为组件创建自定义类型描述提供程序。然后我们将为我们的组件注册提供程序。

public class MyTypeDescriptionProvider : TypeDescriptionProvider
{
    public MyTypeDescriptionProvider()
       : base(TypeDescriptor.GetProvider(typeof(object))) { }

    public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, 
                                                            object instance)
    {
       ICustomTypeDescriptor baseDescriptor = base.GetTypeDescriptor(objectType, instance);
       return new MyTypeDescriptor(baseDescriptor);
    }
}

TypeDescriptor

TypeDescriptor

Here we implement our type descriptor which it's job is returning a list of our custom property descriptors.

这里我们实现了我们的类型描述符，它的工作是返回我们的自定义属性描述符列表。

public class MyTypeDescriptor : CustomTypeDescriptor
{
    ICustomTypeDescriptor original;
    public MyTypeDescriptor(ICustomTypeDescriptor originalDescriptor)
        : base(originalDescriptor)
    {
        original = originalDescriptor;
    }
    public override PropertyDescriptorCollection GetProperties()
    {
        return this.GetProperties(new Attribute[] { });
    }
    public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
    {
        var properties = base.GetProperties(attributes).Cast<PropertyDescriptor>()
                             .Select(p => new MyPropertyDescriptor(p))
                             .ToArray();
        return new PropertyDescriptorCollection(properties);
    }
}

PropertyDescriptor

的PropertyDescriptor

Here is the implementation of our custom property descriptor. The implementation of most properties and methods is trivial. Only for ShouldSerialize method, we decide based on having DesignerSerializationVisibility

这是我们的自定义属性描述符的实现。大多数属性和方法的实现都是微不足道的。仅对于ShouldSerialize方法，我们基于具有DesignerSerializationVisibility来决定

public class MyPropertyDescriptor : PropertyDescriptor
{
    PropertyDescriptor original;
    public MyPropertyDescriptor(PropertyDescriptor originalProperty)
        : base(originalProperty)
    {
        original = originalProperty;
    }

    // Implement other properties and methods simply using return original
    // The implementation is trivial like this one:
    // public override Type ComponentType
    // {
    //     get { return original.ComponentType; }
    // }

    public override bool ShouldSerializeValue(object component)
    {
        if (original.Attributes.OfType<DesignerSerializationVisibilityAttribute>()
                .Count() == 0)
            return false;

        return original.ShouldSerializeValue(component);
    }
}

Component

零件

At last here is the component. As you see in the component code, we decorated a property (white list strategy) to be serialized. All other properties will not serialize because it's new behavior which we attached to our properties.

最后这里是组件。正如您在组件代码中看到的那样，我们修饰了一个要序列化的属性（白名单策略）。所有其他属性都不会序列化，因为它是我们附加到属性的新行为。

[TypeDescriptionProvider(typeof(MyTypeDescriptionProvider))]
public class MyCustomClass : Component
{
    public string Property1 { get; set; }
    public string Property2 { get; set; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
    public string Property3 { get; set; }
}