DesignerSerializationManager Classe

Definição

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

Herança

Object

DesignerSerializationManager

Implementações

IDesignerSerializationManager IServiceProvider

Comentários

A IDesignerSerializationManager interface foi projetada para ser uma interface independente de formato para um objeto que controla a serialização. Ele essencialmente fornece contexto e serviços para serializadores, que realmente executam a desserialização. IDesignerSerializationManager auxilia no processo de desserialização mantendo o controle de objetos. Isso é semelhante na técnica da IDesignerHost interface do usuário: os designers realmente fornecem a interface do usuário e IDesignerHost fornecem a cola que permite que diferentes designers trabalhem juntos.

A classe DesignerSerializationManager implementa IDesignerSerializationManager. Ele foi projetado para fornecer uma forma genérica de desserialização semelhante a serializadores em tempo de execução, como o BinaryFormatter.

A DesignerSerializationManager classe atinge três metas:

• É um objeto simples e turnkey que pode ser usado para desserializar uma variedade de formatos.

• Ele é genérico e não está vinculado a nenhum formato específico. Ele pode ser usado igualmente para desserialização de CodeDOM, bem como desserialização de marcação.

• Ele é extensível e dá suporte a diferentes métodos de serialização que são usados em cenários de cópia/colagem e desfazer/refazer.

A serialização em tempo de design tem as seguintes diferenças em relação à serialização de objetos em tempo de execução:

• O objeto que executa a serialização geralmente é separado do objeto de tempo de execução, para que a lógica de tempo de design possa ser removida de um componente.

• O esquema de serialização pressupõe que o objeto será criado totalmente inicializado e modificado por meio de invocações de propriedade e método durante a desserialização.

• As propriedades de um objeto que têm valores que nunca foram definidos no objeto (as propriedades contêm os valores padrão) não são serializadas. Por outro lado, o fluxo de desserialização pode ter buracos.

• A ênfase é colocada na qualidade do conteúdo dentro do fluxo de serialização, em vez da serialização completa de um objeto. Isso significa que, se não houver uma maneira definida de serializar um objeto, esse objeto poderá ser ignorado em vez de gerar uma exceção. O mecanismo de serialização pode fornecer heurística aqui para decidir quais falhas podem ser ignoradas e quais são irrecuperáveis.

• O fluxo de serialização pode ter mais dados do que o necessário para desserialização. A serialização do código-fonte, por exemplo, tem o código do usuário misturado com o código necessário para desserializar um grafo de objeto. Esse código de usuário deve ser ignorado na desserialização e preservado na serialização.

Devido a essas diferenças, um modelo de serialização diferente se aplica à serialização em tempo de design. Esse modelo utiliza um objeto serializador separado para cada tipo de dados que está sendo serializado. Cada serializador fornece sua pequena contribuição para o problema como um todo. Esses serializadores são todos coordenados por meio de um gerenciador de serialização comum. O gerenciador de serialização é responsável por manter o estado entre esses serializadores diferentes. Por exemplo, considere a seguinte classe:

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

Uma instância dessa classe utilizaria três serializadores diferentes: um para SampleObject, um para cadeias de caracteres e outro para inteiros. O serializador para SampleObject é chamado de serializador raiz porque SampleObject é a raiz do grafo de serialização. Grafos de objeto mais complexos também podem ser criados. Por exemplo, considere o que aconteceria se SampleObject fosse alterado da seguinte maneira:

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

Isso permite SampleObject ter um filho que seja outra instância de si mesmo. O código a seguir preenche o grafo de objeto:

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

Quando root for serializado, haverá quatro serializadores usados: um serializador raiz, um serializador para o filho SampleObject, um serializador para inte um serializador para string. Os serializadores são armazenados em cache com base no tipo , portanto, não é necessário criar um serializador para cada instância do SampleObject.

A DesignerSerializationManager classe é baseada na ideia de uma sessão de serialização. Uma sessão mantém o estado que pode ser acessado pelos vários serializadores. Quando uma sessão é descartada, esse estado é destruído. Isso ajuda a garantir que os serializadores permaneçam em grande parte sem estado e ajuda a limpo serializadores corrompidos. As tabelas a seguir descrevem como o estado é gerenciado dentro e entre sessões.

Estado Global

Esse estado pertence ao objeto do gerenciador de serialização, mas é independente da sessão de serialização atual.

Estado do Session-Owned

Esse estado pertence a uma sessão e é destruído quando uma sessão é destruída. Consequentemente, acessar quaisquer propriedades ou métodos que manipulem esse estado gerará uma exceção se o gerenciador de serialização não estiver em uma sessão ativa.

Construtores

Propriedades

Métodos

Eventos

Implantações explícitas de interface

Aplica-se a

Confira também

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider