Condividi tramite


DesignerSerializationManager Classe

Definizione

Fornisce un'implementazione dell'interfaccia 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
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.

Implementazioni dell'interfaccia esplicita

IDesignerSerializationManager.AddSerializationProvider(IDesignerSerializationProvider)

Aggiunge un provider di serializzazione personalizzato al gestore della serializzazione.

IDesignerSerializationManager.Context

Ottiene lo stack di contesto per questa sessione di serializzazione.

IDesignerSerializationManager.CreateInstance(Type, ICollection, String, Boolean)

Implementa il metodo CreateInstance(Type, ICollection, String, Boolean).

IDesignerSerializationManager.GetInstance(String)

Recupera un'istanza di un oggetto creato con il nome specificato.

IDesignerSerializationManager.GetName(Object)

Recupera un nome per l'oggetto specificato.

IDesignerSerializationManager.GetSerializer(Type, Type)

Ottiene un serializzatore del tipo richiesto per il tipo di oggetto specificato.

IDesignerSerializationManager.GetType(String)

Ottiene un tipo del nome specificato.

IDesignerSerializationManager.Properties

Implementa la proprietà Properties.

IDesignerSerializationManager.RemoveSerializationProvider(IDesignerSerializationProvider)

Rimuove un provider di serializzazione aggiunto in precedenza.

IDesignerSerializationManager.ReportError(Object)

Utilizzato per segnalare un errore risolvibile nella serializzazione.

IDesignerSerializationManager.ResolveName

Viene generato quando il metodo IDesignerSerializationManager.GetName(Object) non è in grado di individuare il nome specificato nella tabella dei nomi del gestore della serializzazione.

IDesignerSerializationManager.SerializationComplete

Viene generato al termine della serializzazione.

IDesignerSerializationManager.SetName(Object, String)

Imposta il nome per l'oggetto specificato.

IServiceProvider.GetService(Type)

Per una descrizione di questo membro, vedere il metodo GetService(Type).

Si applica a

Vedi anche