DesignerSerializationManager Classe

Definizione

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à

Object

DesignerSerializationManager

Implementazioni

IDesignerSerializationManager IServiceProvider

Commenti

L'interfaccia IDesignerSerializationManager è progettata per essere un'interfaccia indipendente dal formato a un oggetto che controlla la serializzazione. Fornisce essenzialmente contesto e servizi ai serializzatori, che in realtà eseguono la deserializzazione. IDesignerSerializationManager assiste nel processo di deserializzazione tenendo traccia degli oggetti. Si tratta di una tecnica simile all'interfaccia IDesignerHost : i progettisti forniscono effettivamente l'interfaccia utente e IDesignerHost forniscono l'associazione che consente a finestre di progettazione diverse di collaborare.

La DesignerSerializationManager classe implementa IDesignerSerializationManager. È progettato per fornire una forma generica di deserializzazione simile ai serializzatori in fase di esecuzione, ad esempio BinaryFormatter.

La DesignerSerializationManager classe raggiunge tre obiettivi:

• Si tratta di un semplice oggetto chiavi in mano che può essere usato per deserializzare un'ampia gamma di formati.

• È generico e non legato ad alcun formato particolare. Può essere usato allo stesso modo per la deserializzazione CodeDOM e la deserializzazione del markup.

• È estendibile e supporta diversi metodi di serializzazione usati in scenari di copia/incolla e annullamento/rollforward.

La serializzazione in fase di progettazione presenta le differenze seguenti rispetto alla serializzazione degli oggetti in fase di esecuzione:

• 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 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. Viceversa, il flusso di deserializzazione può 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 un modo definito per serializzare un oggetto, tale oggetto può essere ignorato anziché generare un'eccezione. Il motore di serializzazione può fornire euristica qui per decidere quali errori possono essere ignorati e quali sono irreversibili.

• Il flusso di serializzazione può avere più dati di quanto necessario per la deserializzazione. La serializzazione del codice sorgente, ad esempio, include codice utente misto con il codice necessario per deserializzare un oggetto grafico. Questo codice utente deve essere ignorato in caso di deserializzazione e conservato durante la serializzazione.

A causa di queste differenze, un modello di serializzazione diverso si applica alla serializzazione in fase di progettazione. Questo modello utilizza un oggetto serializzatore separato per ogni tipo di dati da serializzare. Ogni serializzatore fornisce il suo piccolo contributo al problema nel suo complesso. Questi serializzatori sono tutti coordinati tramite un gestore di serializzazione comune. Il gestore della serializzazione è responsabile del mantenimento dello stato tra questi diversi serializzatori. 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 i numeri interi. Il serializzatore per SampleObject è denominato 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 di SampleObject avere un figlio che è un'altra istanza di se stessa. Il codice seguente compila l'oggetto grafico:

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, verranno usati quattro serializzatori: un serializzatore radice, un serializzatore per l'elemento figlio SampleObject, un serializzatore per inte un serializzatore per string. I serializzatori vengono memorizzati nella cache in base al tipo, pertanto 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 accessibile dai vari serializzatori. Quando una sessione viene eliminata, questo stato viene eliminato definitivamente. 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 viene gestito lo stato in e tra le sessioni.

Stato globale

Questo stato è di proprietà dell'oggetto gestore della serializzazione, ma è indipendente dalla sessione di serializzazione corrente.

stato Session-Owned

Questo stato è di proprietà di una sessione e viene eliminato definitivamente quando una sessione viene eliminata definitivamente. Di conseguenza, l'accesso a qualsiasi proprietà o metodo che modifica questo stato genererà un'eccezione se il gestore di serializzazione non si trova in una sessione attiva.

Vedi anche

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider