DesignerSerializationManager Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Fornece uma implementação da interface IDesignerSerializationManager.
public ref class DesignerSerializationManager : IServiceProvider, System::ComponentModel::Design::Serialization::IDesignerSerializationManagerpublic class DesignerSerializationManager : IServiceProvider, System.ComponentModel.Design.Serialization.IDesignerSerializationManagertype DesignerSerializationManager = class
interface IDesignerSerializationManager
interface IServiceProviderPublic Class DesignerSerializationManager
Implements IDesignerSerializationManager, IServiceProvider- Herança
-
DesignerSerializationManager
- Implementações
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.
| Objeto | Uso |
|---|---|
| Provedores de serialização | Os objetos podem se adicionar como provedores de serialização personalizados. Como esses provedores são usados para localizar serializadores, eles sobrevivem a uma sessão de serialização. |
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.
| Objeto | Uso |
|---|---|
| Evento ResolveName | O ResolveName evento é anexado por um serializador para fornecer resolução adicional de nomes. Todos os manipuladores são desanexados desse evento quando uma sessão é encerrada. |
| Evento SerializationComplete | O SerializationComplete evento é gerado pouco antes de uma sessão ser descartada. Em seguida, todos os manipuladores são desanexados desse evento. |
| Tabela de nomes | O gerenciador de serialização mantém uma tabela que mapeia entre objetos e seus nomes. Serializadores podem fornecer nomes de objetos para facilitar a identificação. Essa tabela de nomes é desmarcada quando a sessão é encerrada. |
| Cache do serializador | O gerenciador de serialização mantém um cache de serializadores que foi solicitado a fornecer. Esse cache é limpo quando a sessão é encerrada. O método público GetSerializer pode ser chamado com segurança a qualquer momento, mas seu valor será armazenado em cache somente se for chamado de dentro de uma sessão. |
| Pilha de contexto | O gerenciador de serialização mantém um objeto chamado pilha de contexto, que você pode acessar com a Context propriedade . Os serializadores podem usar essa pilha para armazenar informações adicionais disponíveis para outros serializadores. Por exemplo, um serializador que está serializando um valor de propriedade pode efetuar push do nome da propriedade na pilha de serialização antes de solicitar que o valor seja serializado. Essa pilha é desmarcada quando a sessão é encerrada. |
| Lista de erros | O gerenciador de serialização mantém uma lista de erros ocorridos durante a serialização. Essa lista, que é acessada por meio da Errors propriedade , é desmarcada quando a sessão é encerrada. Acessar a Errors propriedade entre sessões resultará em uma exceção. |
Construtores
| DesignerSerializationManager() |
Inicializa uma nova instância da classe DesignerSerializationManager. |
| DesignerSerializationManager(IServiceProvider) |
Inicializa uma nova instância da classe DesignerSerializationManager com o provedor de serviços fornecido. |
Propriedades
| Container |
Obtém ou define o contêiner para este gerenciador de serialização. |
| Errors |
Obtém a lista de erros que ocorreram durante a serialização ou desserialização. |
| PreserveNames |
Obtém ou define um valor que indica se o método CreateInstance(Type, ICollection, String, Boolean) deve verificar a presença do nome fornecido no contêiner. |
| PropertyProvider |
Obtém o objeto que deve ser usado para fornecer as propriedades a propriedade Properties do gerenciador de serialização. |
| RecycleInstances |
Obtém ou define um valor que indica se CreateInstance(Type, ICollection, String, Boolean) sempre criará uma instância de um tipo. |
| ValidateRecycledTypes |
Obtém ou define um valor que indica se o método CreateInstance(Type, ICollection, String, Boolean) verificará se os nomes correspondentes se referem ao mesmo tipo. |
Métodos
| CreateInstance(Type, ICollection, String, Boolean) |
Cria uma instância de um tipo. |
| CreateSession() |
Cria uma nova sessão de serialização. |
| Equals(Object) |
Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object) |
| GetHashCode() |
Serve como a função de hash padrão. (Herdado de Object) |
| GetRuntimeType(String) |
Obtém o tipo correspondente ao nome do tipo especificado. |
| GetSerializer(Type, Type) |
Obtém o serializador para o tipo de objeto especificado. |
| GetService(Type) |
Obtém o serviço solicitado. |
| GetType() |
Obtém o Type da instância atual. (Herdado de Object) |
| GetType(String) |
Obtém o tipo solicitado. |
| MemberwiseClone() |
Cria uma cópia superficial do Object atual. (Herdado de Object) |
| OnResolveName(ResolveNameEventArgs) |
Aciona o evento ResolveName. |
| OnSessionCreated(EventArgs) |
Aciona o evento SessionCreated. |
| OnSessionDisposed(EventArgs) |
Aciona o evento SessionDisposed. |
| ToString() |
Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object) |
Eventos
| SessionCreated |
Ocorre quando uma sessão é criada. |
| SessionDisposed |
Ocorre quando uma sessão é descartada. |
