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 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.

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.

Costruttori

Proprietà

Metodi

Eventi

Implementazioni dell'interfaccia esplicita

Si applica a

Vedi anche

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider