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

Observações

A IDesignerSerializationManager interface foi concebida para ser uma interface independente do formato para um objeto que controla a serialização. Essencialmente, fornece contexto e serviços aos serializadores, que efetivamente realizam a desserialização. IDesignerSerializationManager auxilia no processo de desserialização ao acompanhar os objetos. Isto é semelhante na técnica à IDesignerHost interface: os designers fornecem efetivamente a interface de utilizador (UI) e IDesignerHost fornece a cola que permite que diferentes designers trabalhem em conjunto.

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

A DesignerSerializationManager turma alcança três objetivos:

• É um objeto simples e turnkey que pode ser usado para desserializar vários formatos.

• É genérico e não está ligado a nenhum formato em particular. Pode ser usado tanto para desserialização de CodeDOM como para desserialização de marcação.

• É extensível e suporta diferentes métodos de serialização usados em cenários de copiar/colar e desfazer/refazer.

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

• O objeto que realiza a serialização é geralmente separado do objeto em tempo de execução, pelo que a lógica em tempo de projeto pode ser removida de um componente.

• O esquema de serialização assume que o objeto será criado totalmente inicializado e depois modificado através de invocações de propriedades e métodos durante a desserialização.

• 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 é dada à qualidade do conteúdo dentro do fluxo de serialização, em vez da serialização completa de um objeto. Isto significa que, se não houver uma forma definida de serializar um objeto, esse objeto pode ser ignorado em vez de lançar uma exceção. O motor de serialização pode fornecer heurísticas 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 a desserialização. A serialização do código-fonte, por exemplo, tem código de utilizador misturado com o código necessário para desserializar um grafo de objetos. Este código de utilizador deve ser ignorado na desserialização e preservado na serialização.

Devido a estas diferenças, aplica-se um modelo de serialização diferente à serialização em tempo de projeto. Este modelo utiliza um objeto serializador separado para cada tipo de dado a ser serializado. Cada serializador fornece a sua pequena contribuição para o problema como um todo. Estes serializadores são todos coordenados através de um gestor comum de serialização. O gestor de serialização é responsável por manter o estado entre estes diferentes serializadores. Como 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 desta classe utilizaria três serializadores diferentes: um para SampleObject, um para cadeias e outro para inteiros. O serializador para SampleObject é chamado de serializador raiz porque SampleObject é a raiz do grafo de serialização. Também podem ser criados grafos de objeto mais complexos. Por exemplo, considere o que aconteceria se SampleObject fosse alterado da seguinte forma:

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

Isto permite SampleObject ter um filho que é outra instância de si mesmo. O seguinte código preenche o grafo 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

Quando root é serializado, serão usados quatro serializadores: um serializador raiz, um serializador para o filho SampleObject, um serializador para int, e um serializador para string. Os serializadores são armazenados em cache com base no tipo, pelo que não há necessidade de criar um serializador para cada instância de SampleObject.

A DesignerSerializationManager classe baseia-se na ideia de uma sessão de serialização. Uma sessão mantém um estado que pode ser acedido pelos vários serializadores. Quando uma sessão é eliminada, esse estado é destruído. Isto ajuda a garantir que os serializadores permanecem em grande parte sem estado e ajuda a limpar os serializadores que foram corrompidos. As tabelas seguintes descrevem como o Estado é gerido dentro e entre sessões.

Estado Global

Este estado pertence ao objeto gestor de serialização, mas é independente da sessão de serialização atual.

Session-Owned Estado

Este estado pertence a uma sessão e é destruído quando uma sessão é destruída. Consequentemente, aceder a quaisquer propriedades ou métodos que manipulem este estado lançará uma exceção se o gestor de serialização não estiver numa sessão ativa.

Ver também

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider