DesignerSerializationManager Clase

Definición

Espacio de nombres:

System.ComponentModel.Design.Serialization

Ensamblado:

System.Windows.Forms.Design.dll

Proporciona una implementación de la interfaz IDesignerSerializationManager.

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 serializadores, que realmente realizan la deserialización. IDesignerSerializationManager ayuda en el proceso de deserialización mediante el seguimiento de objetos. Esto es similar en técnica a la IDesignerHost interfaz: los diseñadores realmente proporcionan la interfaz de usuario (UI) y IDesignerHost proporcionan el pegamento que permite a los distintos diseñadores trabajar juntos.

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

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 iniciar 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.

• El flujo de serialización puede tener más datos de los necesarios para la deserialización. La serialización de 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, un modelo de serialización diferente se aplica a la serialización en tiempo de diseño. Este modelo utiliza un objeto serializador independiente para cada tipo de datos que se está serializando. 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 serializadores diferentes. 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 , otro para SampleObjectcadenas 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 tener un elemento secundario SampleObject 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 ayudan 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 localizar serializadores, sobrevivirán a 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
EventoResolveName	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.
EventoSerializationComplete	El SerializationComplete evento se genera justo antes de eliminar 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 dar 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 contextos	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 que está 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

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

Propiedades

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

Métodos

CreateInstance(Type, ICollection, String, Boolean)	Crea una instancia de un tipo.
CreateSession()	Crea una nueva sesión de serialización.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetRuntimeType(String)	Obtiene el tipo que se corresponde con el nombre de tipo especificado.
GetSerializer(Type, Type)	Obtiene el serializador para el tipo de objeto especificado.
GetService(Type)	Obtiene el servicio solicitado.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetType(String)	Obtiene el tipo solicitado.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
OnResolveName(ResolveNameEventArgs)	Genera el evento ResolveName.
OnSessionCreated(EventArgs)	Genera el evento SessionCreated.
OnSessionDisposed(EventArgs)	Genera el evento SessionDisposed.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Eventos

SessionCreated	Tiene lugar cuando se crea una sesión.
SessionDisposed	Se produce cuando se desecha una sesión.

Implementaciones de interfaz explícitas

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 método CreateInstance(Type, ICollection, String, Boolean).
IDesignerSerializationManager.GetInstance(String)	Recupera una instancia de un objeto creado con el 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 propiedad Properties.
IDesignerSerializationManager.RemoveSerializationProvider(IDesignerSerializationProvider)	Quita un proveedor de serialización agregado anteriormente.
IDesignerSerializationManager.ReportError(Object)	Se utiliza para crear un informe de error recuperable en la serialización.
IDesignerSerializationManager.ResolveName	Tiene lugar cuando IDesignerSerializationManager.GetName(Object) no puede encontrar el nombre especificado en la tabla de nombres del administrador de serialización.
IDesignerSerializationManager.SerializationComplete	Se produce al finalizar la serialización.
IDesignerSerializationManager.SetName(Object, String)	Establece el nombre para el objeto especificado.
IServiceProvider.GetService(Type)	Para obtener una descripción de este miembro, vea el método GetService(Type).

Consulte también

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider