为什么C＃SerializedAttribute是密封的？

Question

I was trying to create an attribute that implies [Serializable] but I noticed that this SerializableAttribute class is sealed.

In Java it was possible to create an interface (say, MyInterface ) that is inherited from Serializable interface and so all the subclasses of MyInterface would also be serializable, even its sub-sub classes would be so.

Let's say I am creating an ORM and I want customers to annotate their entity classes as [DatabaseEntity] but in order to make sure that entities are serializable, I also need to ask them to attribute their classes with extra [Serializable] which does not look quite compact and neat.

I am wondering why SerializableAttribute class is sealed and why has Inherited=false which implies that subclasses of serializable class will not be serializable unless it is explicitly stated. What motives are behind these design choices?

Answer 1

The SerializableAttribute is only used by the BinaryFormatter. If you are writing your own serialiser then don't worry about.

The sealed keyword is applied to the attribute not the class associated with the attribute. It is saying that the SerializableAttribute cannot be subclassed.

The BinaryFormatter uses an opt-in model. Any class (or subclass) must specify that it is serializable. This why the Inherited=false is used.

Answer 2

It's suggested best practice that all .Net attributes should be sealed, according to Microsoft :

The .NET Framework class library provides methods for retrieving custom attributes. By default, these methods search the attribute inheritance hierarchy; for example System.Attribute.GetCustomAttribute searches for the specified attribute type, or any attribute type that extends the specified attribute type. Sealing the attribute eliminates the search through the inheritance hierarchy, and can improve performance . [my emphasis]

So [Serializable] is sealed because it's quicker for .Net reflection to check the attributes. The cost is that you can't inherit and extend SerializableAttribute .

You can make your own un-sealed attributes if you want (you'll get code analysis warnings though).

This gets a little confusing with how attributes are used in inheritance for the classes that they apply to. It's probably best to use an example:

[Serializable]
public class A
{
    public int SimpleSerialisableProperty { get; set;}
}

public class B : A
{
    public C ComplexReferenceProperty { get; set; }
}

[Serializable]
public class D : A
{
    public bool AnotherSerialisableProperty { get; set;}
}

You asked why SerializableAttribute.Inherited = false and this is why:

• Class A is marked as [Serializable] , and it is.

• However class B inherits A and extends it with properties that are not serialisable. If .Net tries to serialise B it will encounter an error.

• That Inherited = false tells .Net that just because A has been marked as [Serializable] not every class that inherits it will be serialisable too.

• Now class D inherits A and is serialisable, so it gets its own [Serializable] attribute.

Finally, in terms of design attributes are a great way of extending behaviour (nice UI editors in property grids, etc). However they are terrible at enforcing it. If you need your customers to implement their entity classes in a particular way then an abstract base class or an interface is a much better way to go. If you make it an attribute then you're basically letting them know that [Serializable] is an option that you can handle either way.

Answer 3

Serialization is not a magic thing and you don't need any attribute to serialize an object. It is a process of writing your class' properties and fields to a stream (and attributes are only directives to serializers about how to behave while outputting an object).

See this over-simplified serializer code which totally ignores all attributes including NonSerializable

object obj = yourObject;

var props = obj.GetType()
               .GetProperties()
               .ToDictionary(p => p.Name, p => p.GetValue(obj, null));

string serializedText = String.Join("\n",
              props.Select(kv => kv.Key + "=" + kv.Value ?? kv.Value.ToString()));

Above code, for example, would give

IsEmpty=False
X=3
Y=5

for object obj = new Point(3,5);

Deserialization process would be to read these values and set the properties back accordingly.

Answer 4

Put the [Serializable] attribute on top of the class you want serialized. Serialization is opt-in process. You have to manually do that for each class you want serialized. There are bunch of other keywords.