DesignerSerializationManager Clase

Definición

Espacio de nombres:

System.ComponentModel.Design.Serialization

Ensamblado:

System.Windows.Forms.Design.dll

Source:

DesignerSerializationManager.cs

Proporciona una implementación de la IDesignerSerializationManager interfaz .

public ref class DesignerSerializationManager : IServiceProvider, System::ComponentModel::Design::Serialization::IDesignerSerializationManager

public class DesignerSerializationManager : IServiceProvider, System.ComponentModel.Design.Serialization.IDesignerSerializationManager

type DesignerSerializationManager = class
    interface IDesignerSerializationManager
    interface IServiceProvider

Public Class DesignerSerializationManager
Implements IDesignerSerializationManager, IServiceProvider

Herencia

Object

DesignerSerializationManager

Comentarios

La IDesignerSerializationManager interfaz está diseñada para ser una interfaz independiente del formato para un objeto que controla la serialización. Básicamente proporciona contexto y servicios a los serializadores, que realmente realizan la deserialización. IDesignerSerializationManager ayuda en el proceso de deserialización realizando un seguimiento de los objetos. Esto es similar en técnica a la IDesignerHost interfaz: los diseñadores proporcionan realmente la interfaz de usuario (UI) y IDesignerHost proporcionan el pegamento que permite a los distintos diseñadores trabajar juntos.

La DesignerSerializationManager clase implementa IDesignerSerializationManager. Está diseñado para proporcionar una forma genérica de deserialización similar a los serializadores en tiempo de ejecución, como .BinaryFormatter

La DesignerSerializationManager clase logra tres objetivos:

• Es un objeto simple y llave en mano que se puede usar para deserializar una variedad de formatos.

• Es genérico y no está asociado a ningún formato determinado. Se puede usar igualmente para la deserialización CodeDOM, así como para la deserialización de marcado.

• Es extensible y admite diferentes métodos de serialización que se usan en escenarios de copia/pegado y deshacer/rehacer.

La serialización en tiempo de diseño tiene las siguientes diferencias respecto a la serialización de objetos en tiempo de ejecución:

• El objeto que realiza la serialización suele ser independiente del objeto en tiempo de ejecución, de modo que la lógica en tiempo de diseño se pueda quitar de un componente.

• El esquema de serialización supone que el objeto se creará completamente inicializado y, a continuación, se modificará a través de las invocaciones de propiedad y método durante la deserialización.

• Las propiedades de un objeto que tienen valores que nunca se establecieron en el objeto (las propiedades contienen los valores predeterminados) no se serializan. Por el contrario, la secuencia de deserialización puede tener agujeros.

• El énfasis se coloca en la calidad del contenido dentro del flujo de serialización, en lugar de en la serialización completa de un objeto. Esto significa que si no hay ninguna manera definida de serializar un objeto, ese objeto se puede omitir en lugar de producir una excepción. El motor de serialización puede proporcionar heurística aquí para decidir qué errores se pueden omitir y cuáles son irrecuperables.

• La secuencia de serialización puede tener más datos de los necesarios para la deserialización. La serialización del código fuente, por ejemplo, tiene código de usuario mixto con el código necesario para deserializar un gráfico de objetos. Este código de usuario debe omitirse en la deserialización y conservarse en la serialización.

Debido a estas diferencias, se aplica un modelo de serialización diferente a la serialización en tiempo de diseño. Este modelo utiliza un objeto serializador independiente para cada tipo de datos que se va a serializar. Cada serializador proporciona su pequeña contribución al problema en su conjunto. Estos serializadores se coordinan a través de un administrador de serialización común. El administrador de serialización es responsable de mantener el estado entre estos diferentes serializadores. Por ejemplo, considere la siguiente clase:

public class SampleObject
{
    private string stringValue = null;
    private int intValue = int.MinValue;

    public string StringProperty 
    { 
        get { return this.stringValue; }

        set { this.stringValue = value; }
    }

    public int IntProperty 
    {
        get { return this.intValue; }

        set{ this.intValue = value; }
    }
}

Public Class SampleObject
   Private stringValue As String = Nothing
   Private intValue As Integer = Integer.MinValue
   
   
   Public Property StringProperty() As String
      Get
         Return Me.stringValue
      End Get 
      Set
         Me.stringValue = value
      End Set
   End Property 
   
   Public Property IntProperty() As Integer
      Get
         Return Me.intValue
      End Get 
      Set
         Me.intValue = value
      End Set
   End Property
End Class

Una instancia de esta clase usaría tres serializadores diferentes: uno para SampleObject, otro para cadenas y otro para enteros. El serializador para SampleObject se denomina serializador raíz porque SampleObject es la raíz del gráfico de serialización. También se pueden crear gráficos de objetos más complejos. Por ejemplo, considere lo que sucedería si SampleObject se cambiara de la siguiente manera:

public class SampleObject
{
    private string stringValue = null;
    private int intValue = int.MinValue;
    private SampleObject childValue = null;

    public string StringProperty
    {
        get { return this.stringValue; }

        set { this.stringValue = value; }
    }

    public int IntProperty
    {
        get { return this.intValue; }

        set { this.intValue = value; }
    }

    public SampleObject Child
    {
        get { return this.childValue; }

        set { this.childValue = value; }
    }
}

Public Class SampleObject
   Private stringValue As String = Nothing
   Private intValue As Integer = Integer.MinValue
   Private childValue As SampleObject = Nothing
   
   
   Public Property StringProperty() As String
      Get
         Return Me.stringValue
      End Get 
      Set
         Me.stringValue = value
      End Set
   End Property 
   
   Public Property IntProperty() As Integer
      Get
         Return Me.intValue
      End Get 
      Set
         Me.intValue = value
      End Set
   End Property 
   
   Public Property Child() As SampleObject
      Get
         Return Me.childValue
      End Get 
      Set
         Me.childValue = value
      End Set
   End Property
End Class

Esto permite SampleObject tener un elemento secundario que sea otra instancia de sí misma. El código siguiente rellena el gráfico de objetos:

class Program
{
    static void Main(string[] args)
    {
        SampleObject root = new SampleObject();

        SampleObject currentObject = root;

        for (int i = 0; i < 10; i++)
        {
            SampleObject o = new SampleObject();

            currentObject.Child = o;

            currentObject = o;
        }
    }
}

Class Program
   
   Public Overloads Shared Sub Main()
      Main(System.Environment.GetCommandLineArgs())
   End Sub
   
   Overloads Shared Sub Main(args() As String)
      Dim root As New SampleObject()
      
      Dim currentObject As SampleObject = root
      
      Dim i As Integer
      For i = 0 To 9
         Dim o As New SampleObject()
         
         currentObject.Child = o
         
         currentObject = o
      Next i
   End Sub 
End Class

Cuando root se serializa, habrá cuatro serializadores usados: un serializador raíz, un serializador para el secundario SampleObject, un serializador para inty un serializador para string. Los serializadores se almacenan en caché en función del tipo, por lo que no es necesario crear un serializador para cada instancia de SampleObject.

La DesignerSerializationManager clase se basa en la idea de una sesión de serialización. Una sesión mantiene el estado al que pueden acceder los distintos serializadores. Cuando se elimina una sesión, este estado se destruye. Esto ayuda a garantizar que los serializadores permanecen en gran medida sin estado y ayuda a limpiar los serializadores dañados. En las tablas siguientes se describe cómo se administra el estado en y entre las sesiones.

Estado global

Este estado es propiedad del objeto del administrador de serialización, pero es independiente de la sesión de serialización actual.

Objeto	Uso
Proveedores de serialización	Los objetos se pueden agregar como proveedores de serialización personalizados. Dado que estos proveedores se usan para buscar serializadores, aparecen en una sesión de serialización.

estado de Session-Owned

Este estado es propiedad de una sesión y se destruye cuando se destruye una sesión. Por lo tanto, el acceso a las propiedades o métodos que manipularían este estado producirá una excepción si el administrador de serialización no está en una sesión activa.

Objeto	Uso
ResolveName evento	Un ResolveName serializador adjunta el evento para proporcionar una resolución adicional de nombres. Todos los controladores se desasocian de este evento cuando finaliza una sesión.
SerializationComplete evento	El SerializationComplete evento se genera justo antes de que se elimine una sesión. A continuación, todos los controladores se desasocian de este evento.
Tabla de nombres	El administrador de serialización mantiene una tabla que se asigna entre los objetos y sus nombres. Los serializadores pueden proporcionar nombres de objetos para facilitar la identificación. Esta tabla de nombres se borra cuando finaliza la sesión.
Caché del serializador	El administrador de serialización mantiene una memoria caché de serializadores que se le ha pedido que proporcione. Esta memoria caché se borra cuando finaliza la sesión. El método público GetSerializer se puede llamar de forma segura en cualquier momento, pero su valor solo se almacena en caché si se llama desde dentro de una sesión.
Pila de contexto	El administrador de serialización mantiene un objeto denominado pila de contexto, al que puede acceder con la Context propiedad . Los serializadores pueden usar esta pila para almacenar información adicional disponible para otros serializadores. Por ejemplo, un serializador que serializa un valor de propiedad puede insertar el nombre de propiedad en la pila de serialización antes de pedir al valor que se serialice. Esta pila se borra cuando finaliza la sesión.
Lista de errores	El administrador de serialización mantiene una lista de errores que se produjeron durante la serialización. Esta lista, a la que se accede a través de la Errors propiedad , se borra cuando finaliza la sesión. El acceso a la Errors propiedad entre sesiones producirá una excepción.

Constructores

Nombre	Description
DesignerSerializationManager()	Inicializa una nueva instancia de la clase DesignerSerializationManager.
DesignerSerializationManager(IServiceProvider)	Inicializa una nueva instancia de la DesignerSerializationManager clase con el proveedor de servicios especificado.

Propiedades

Nombre	Description
Container	Obtiene o establece en el contenedor para este administrador de serialización.
Errors	Obtiene la lista de errores que se produjeron durante la serialización o deserialización.
PreserveNames	Obtiene o establece un valor que indica si el CreateInstance(Type, ICollection, String, Boolean) método debe comprobar la presencia del nombre especificado en el contenedor.
PropertyProvider	Obtiene el objeto que se debe usar para proporcionar propiedades a la propiedad del administrador de Properties serialización.
RecycleInstances	Obtiene o establece un valor que indica si CreateInstance(Type, ICollection, String, Boolean) siempre creará una nueva instancia de un tipo.
ValidateRecycledTypes	Obtiene o establece un valor que indica si el método comprobará que los CreateInstance(Type, ICollection, String, Boolean) nombres coincidentes hacen referencia al mismo tipo.

Métodos

Nombre	Description
CreateInstance(Type, ICollection, String, Boolean)	Crea una instancia de un tipo.
CreateSession()	Crea una nueva sesión de serialización.
GetRuntimeType(String)	Obtiene el tipo correspondiente al nombre de tipo especificado.
GetSerializer(Type, Type)	Obtiene el serializador para el tipo de objeto especificado.
GetService(Type)	Obtiene el servicio solicitado.
GetType(String)	Obtiene el tipo solicitado.
OnResolveName(ResolveNameEventArgs)	Genera el evento ResolveName.
OnSessionCreated(EventArgs)	Genera el evento SessionCreated.
OnSessionDisposed(EventArgs)	Genera el evento SessionDisposed.

Eventos

Nombre	Description
SessionCreated	Se produce cuando se crea una sesión.
SessionDisposed	Se produce cuando se elimina una sesión.

Implementaciones de interfaz explícitas

Nombre	Description
IDesignerSerializationManager.AddSerializationProvider(IDesignerSerializationProvider)	Agrega un proveedor de serialización personalizado al administrador de serialización.
IDesignerSerializationManager.Context	Obtiene la pila de contexto para esta sesión de serialización.
IDesignerSerializationManager.CreateInstance(Type, ICollection, String, Boolean)	Implementa el CreateInstance(Type, ICollection, String, Boolean) método .
IDesignerSerializationManager.GetInstance(String)	Recupera una instancia de un objeto creado del nombre especificado.
IDesignerSerializationManager.GetName(Object)	Recupera un nombre para el objeto especificado.
IDesignerSerializationManager.GetSerializer(Type, Type)	Obtiene un serializador del tipo solicitado para el tipo de objeto especificado.
IDesignerSerializationManager.GetType(String)	Obtiene un tipo del nombre especificado.
IDesignerSerializationManager.Properties	Implementa la Properties propiedad .
IDesignerSerializationManager.RemoveSerializationProvider(IDesignerSerializationProvider)	Quita un proveedor de serialización agregado anteriormente.
IDesignerSerializationManager.ReportError(Object)	Se usa para notificar un error recuperable en la serialización.
IDesignerSerializationManager.ResolveName	Se produce cuando IDesignerSerializationManager.GetName(Object) no se puede encontrar el nombre especificado en la tabla de nombres del administrador de serialización.
IDesignerSerializationManager.SerializationComplete	Se produce cuando se completa la serialización.
IDesignerSerializationManager.SetName(Object, String)	Establece el nombre del objeto especificado.
IServiceProvider.GetService(Type)	Para obtener una descripción de este miembro, consulte el GetService(Type) método .

Consulte también

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider