System.ComponentModel.Design.Serialization.DesignerSerializationManager Class

Provides an implementation of the System.ComponentModel.Design.Serialization.IDesignerSerializationManager interface.

See Also: DesignerSerializationManager Members


public class DesignerSerializationManager : IDesignerSerializationManager


The System.ComponentModel.Design.Serialization.IDesignerSerializationManager interface is designed to be a format-independent interface to an object that controls serialization. It essentially provides context and services to serializers, which actually perform the deserialization. System.ComponentModel.Design.Serialization.IDesignerSerializationManager assists in the deserialization process by keeping track of objects. This is similar in technique to the System.ComponentModel.Design.IDesignerHost interface: designers actually provide the user interface (UI), and System.ComponentModel.Design.IDesignerHost provides the glue that allows different designers to work together.

The System.ComponentModel.Design.Serialization.DesignerSerializationManager class implements System.ComponentModel.Design.Serialization.IDesignerSerializationManager. It is designed to provide a generic form of deserialization that is similar to run-time serializers like the System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.

The System.ComponentModel.Design.Serialization.DesignerSerializationManager class achieves three goals:

Design-time serialization has the following differences from run-time object serialization:

Because of these differences, a different serialization model applies to design-time serialization. This model utilizes a separate serializer object for each data type being serialized. Each serializer provides its small contribution to the problem as a whole. These serializers are all coordinated through a common serialization manager. The serialization manager is responsible for maintaining state between these different serializers. As an example, consider the following class:

code reference: System.ComponentModel.Design.Serialization.DesignerSerializationManager.SampleObject#2

An instance of this class would utilize three different serializers: one for SampleObject, one for strings, and another for integers. The serializer for SampleObject is called the root serializer because SampleObject is the root of the serialization graph. More complex object graphs can be created as well. For example, consider what would happen if SampleObject were changed as follows:

code reference: System.ComponentModel.Design.Serialization.DesignerSerializationManager.SampleObject#11

This allows SampleObject to have a child that is another instance of itself. The following code fills in the object graph:

code reference: System.ComponentModel.Design.Serialization.DesignerSerializationManager.SampleObject#12

When root is serialized, there will be four serializers used: one root serializer, one serializer for the child SampleObject, one serializer for int, and one serializer for string. Serializers are cached based on type, so there is no need to create a serializer for each instance of SampleObject.

The System.ComponentModel.Design.Serialization.DesignerSerializationManager class is based on the idea of a serialization session. A session maintains state that can be accessed by the various serializers. When a session is disposed, this state is destroyed. This helps to ensure that serializers remain largely stateless, and helps to clean up serializers that are have been corrupted. The following tables describe how state is managed in and among sessions.

Global State

This state is owned by the serialization manager object, but is independent of the current serialization session.

Serialization providers

Objects can add themselves as custom serialization providers. Because these providers are used to locate serializers, they outlive a serialization session.

Session-Owned State

This state is owned by a session and is destroyed when a session is destroyed. Consequently, accessing any properties or methods that would manipulate this state will throw an exception if the serialization manager is not in an active session.

IDesignerSerializationManager.ResolveName event

The IDesignerSerializationManager.ResolveName event is attached by a serializer to provide additional resolution of names. All handlers are detached from this event when a session terminates.

IDesignerSerializationManager.SerializationComplete event

The IDesignerSerializationManager.SerializationComplete event is raised just before a session is disposed. Then, all handlers are detached from this event.

Name table

The serialization manager maintains a table that maps between objects and their names. Serializers may give objects names for easy identification. This name table is cleared when the session terminates.

Serializer cache

The serialization manager maintains a cache of serializers it has been asked to supply. This cache is cleared when the session terminates. The public DesignerSerializationManager.GetSerializer(Type, Type) method can safely be called at any time, but its value is cached only if it is called from within a session.

Context stack

The serialization manager maintains an object called the context stack, which you can access with the IDesignerSerializationManager.Context property. Serializers can use this stack to store additional information that is available to other serializers. For example, a serializer that is serializing a property value can push the property name on the serialization stack before asking the value to serialize. This stack is cleared when the session is terminated.

Error list

The serialization manager maintains a list of errors that occurred during serialization. This list, which is accessed through the DesignerSerializationManager.Errors property, is cleared when the session is terminated. Accessing the DesignerSerializationManager.Errors property between sessions will result in an exception.


Namespace: System.ComponentModel.Design.Serialization
Assembly: System.Design (in System.Design.dll)
Assembly Versions: