DesignerSerializationManager Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Fornisce un'implementazione dell'interfaccia 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- Ereditarietà
-
DesignerSerializationManager
- Implementazioni
Commenti
L'interfaccia IDesignerSerializationManager è progettata per essere un'interfaccia indipendente dal formato a un oggetto che controlla la serializzazione. Fornisce essenzialmente il contesto e i servizi ai serializzatori, che in realtà eseguono la deserializzazione. IDesignerSerializationManager aiuta nel processo di deserializzazione mantenendo traccia degli oggetti. Si tratta di una tecnica simile all'interfaccia IDesignerHost : i progettisti forniscono effettivamente l'interfaccia utente (UI) e IDesignerHost fornisce la colla che consente a designer diversi di lavorare insieme.
La DesignerSerializationManager classe implementa IDesignerSerializationManager. È progettato per fornire una forma generica di deserializzazione simile ai serializzatori di runtime come .BinaryFormatter
La DesignerSerializationManager classe raggiunge tre obiettivi:
È un semplice oggetto turnkey che può essere usato per deserializzare un'ampia gamma di formati.
È generico e non legato a alcun formato specifico. Può essere usato ugualmente per la deserializzazione CodeDOM e la deserializzazione del markup.
È estendibile e supporta diversi metodi di serializzazione usati negli scenari di copia/incolla e annullamento/ripristino.
La serializzazione in fase di progettazione presenta le differenze seguenti dalla serializzazione degli oggetti di runtime:
L'oggetto che esegue la serializzazione è in genere separato dall'oggetto runtime, in modo che la logica in fase di progettazione possa essere rimossa da un componente.
Lo schema di serializzazione presuppone che l'oggetto venga creato completamente inizializzato e quindi modificato tramite le chiamate di proprietà e metodo durante la deserializzazione.
Le proprietà di un oggetto con valori che non sono mai stati impostati sull'oggetto (le proprietà contengono i valori predefiniti) non vengono serializzate. Al contrario, il flusso di deserializzazione potrebbe avere fori.
L'enfasi viene posta sulla qualità del contenuto all'interno del flusso di serializzazione, anziché sulla serializzazione completa di un oggetto. Ciò significa che se non esiste alcun modo definito per serializzare un oggetto, tale oggetto può essere ignorato anziché generare un'eccezione. Il motore di serializzazione può fornire l'euristica qui per decidere quali errori possono essere ignorati e quali sono non recuperabili.
Il flusso di serializzazione può avere più dati che necessari per la deserializzazione. La serializzazione del codice sorgente, ad esempio, include codice utente misto con il codice necessario per deserializzare un grafico a oggetti. Questo codice utente deve essere ignorato sulla deserializzazione e mantenuto sulla serializzazione.
A causa di queste differenze, un modello di serializzazione diverso si applica alla serializzazione in fase di progettazione. Questo modello usa un oggetto serializzatore separato per ogni tipo di dati serializzatore. Ogni serializzatore fornisce il suo piccolo contributo al problema nel suo complesso. Questi serializzatori sono tutti coordinati tramite una gestione di serializzazione comune. La gestione della serializzazione è responsabile del mantenimento dello stato tra questi serializzatori diversi. Si consideri, ad esempio, la classe seguente:
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
Un'istanza di questa classe utilizza tre serializzatori diversi: uno per , uno per SampleObjectle stringhe e un altro per gli interi. Il serializzatore per SampleObject viene chiamato serializzatore radice perché SampleObject è la radice del grafico di serializzazione. È anche possibile creare grafici a oggetti più complessi. Si consideri ad esempio cosa accadrebbe se SampleObject fosse stato modificato come segue:
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
Ciò consente SampleObject di avere un figlio che è un'altra istanza di se stessa. Il codice seguente compila il grafico degli oggetti:
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 viene serializzato, ci saranno quattro serializzatori usati: un serializzatore radice, un serializzatore per il figlio SampleObject, un serializzatore per inte un serializzatore per string. I serializzatori vengono memorizzati nella cache in base al tipo, quindi non è necessario creare un serializzatore per ogni istanza di SampleObject.
La DesignerSerializationManager classe si basa sull'idea di una sessione di serializzazione. Una sessione mantiene lo stato a cui è possibile accedere dai vari serializzatori. Quando viene eliminata una sessione, questo stato viene eliminato. Ciò consente di garantire che i serializzatori rimangano in gran parte senza stato e aiutano a pulire i serializzatori danneggiati. Le tabelle seguenti descrivono come lo stato viene gestito in e tra le sessioni.
Stato globale
Questo stato è di proprietà dell'oggetto gestione serializzazione, ma è indipendente dalla sessione di serializzazione corrente.
| Oggetto | Utilizzo |
|---|---|
| Provider di serializzazione | Gli oggetti possono aggiungersi come provider di serializzazione personalizzati. Poiché questi provider vengono usati per individuare serializzatori, superano una sessione di serializzazione. |
Session-Owned stato
Questo stato è di proprietà di una sessione e viene distrutto quando una sessione viene eliminata. Di conseguenza, l'accesso a tutte le proprietà o i metodi che modificano questo stato genererà un'eccezione se la gestione serializzazione non è in una sessione attiva.
| Oggetto | Utilizzo |
|---|---|
| EventoResolveName | L'evento ResolveName è collegato da un serializzatore per fornire una risoluzione aggiuntiva dei nomi. Tutti i gestori vengono scollegati da questo evento quando una sessione termina. |
| EventoSerializationComplete | L'evento viene generato subito prima dell'eliminazione SerializationComplete di una sessione. Tutti i gestori vengono quindi scollegati da questo evento. |
| Tabella dei nomi | Gestione serializzazione gestisce una tabella che esegue il mapping tra gli oggetti e i relativi nomi. I serializzatori possono assegnare nomi agli oggetti per facilitare l'identificazione. Questa tabella dei nomi viene cancellata al termine della sessione. |
| Cache serializzatore | Il gestore della serializzazione gestisce una cache di serializzatori a cui è stato chiesto di fornire. Questa cache viene cancellata al termine della sessione. Il metodo pubblico GetSerializer può essere chiamato in modo sicuro in qualsiasi momento, ma il relativo valore viene memorizzato nella cache solo se viene chiamato dall'interno di una sessione. |
| Stack di contesto | Gestione serializzazione gestisce un oggetto denominato stack di contesto, a cui è possibile accedere con la Context proprietà . I serializzatori possono usare questo stack per archiviare informazioni aggiuntive disponibili per altri serializzatori. Ad esempio, un serializzatore che serializza un valore di proprietà può eseguire il push del nome della proprietà nello stack di serializzazione prima di chiedere al valore di serializzare. Questo stack viene cancellato quando la sessione viene terminata. |
| Elenco errori | Gestione serializzazione gestisce un elenco di errori che si sono verificati durante la serializzazione. Questo elenco, accessibile tramite la Errors proprietà , viene cancellato quando la sessione viene terminata. L'accesso alla Errors proprietà tra le sessioni genererà un'eccezione. |
Costruttori
| DesignerSerializationManager() |
Inizializza una nuova istanza della classe DesignerSerializationManager. |
| DesignerSerializationManager(IServiceProvider) |
Inizializza una nuova istanza della classe DesignerSerializationManager con il provider di servizi dato. |
Proprietà
| Container |
Ottiene o imposta il contenitore per questo gestore della serializzazione. |
| Errors |
Ottiene l'elenco di errori verificatisi durante la serializzazione o deserializzazione. |
| PreserveNames |
Ottiene o imposta un valore che indica se il metodo CreateInstance(Type, ICollection, String, Boolean) deve verificare la presenza del nome dato nel contenitore. |
| PropertyProvider |
Ottiene l'oggetto che deve essere utilizzato per fornire proprietà alla proprietà Properties del gestore della serializzazione. |
| RecycleInstances |
Ottiene o imposta un valore che indica se CreateInstance(Type, ICollection, String, Boolean) creerà sempre una nuova istanza di un tipo. |
| ValidateRecycledTypes |
Ottiene o imposta un valore che indica se il metodo CreateInstance(Type, ICollection, String, Boolean) verificherà che i nomi corrispondenti facciano riferimento allo stesso tipo. |
Metodi
| CreateInstance(Type, ICollection, String, Boolean) |
Crea un'istanza di un tipo. |
| CreateSession() |
Crea una nuova sessione di serializzazione. |
| Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object) |
| GetHashCode() |
Funge da funzione hash predefinita. (Ereditato da Object) |
| GetRuntimeType(String) |
Ottiene il tipo corrispondente al nome del tipo specificato. |
| GetSerializer(Type, Type) |
Ottiene il serializzatore per il tipo di oggetto dato. |
| GetService(Type) |
Ottiene il servizio richiesto. |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| GetType(String) |
Ottiene il tipo richiesto. |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| OnResolveName(ResolveNameEventArgs) |
Genera l'evento ResolveName. |
| OnSessionCreated(EventArgs) |
Genera l'evento SessionCreated. |
| OnSessionDisposed(EventArgs) |
Genera l'evento SessionDisposed. |
| ToString() |
Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object) |
Eventi
| SessionCreated |
Viene generato quando viene creata una sessione. |
| SessionDisposed |
Viene generato quando viene eliminata una sessione. |
