DesignerSerializationManager Klasse

Definition

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

Vererbung

Object

DesignerSerializationManager

Implementiert

IDesignerSerializationManager IServiceProvider

Hinweise

Die IDesignerSerializationManager Schnittstelle ist als formatunabhängige Schnittstelle für ein Objekt konzipiert, das die Serialisierung steuert. Es stellt im Wesentlichen Kontext und Dienste für Serialisierer bereit, die tatsächlich die Deserialisierung ausführen. IDesignerSerializationManager unterstützt den Deserialisierungsprozess, indem Objekte nachverfolgt werden. Dies ähnelt der Technik der IDesignerHost Benutzeroberfläche: Designer stellen tatsächlich die Benutzeroberfläche (UI) bereit und IDesignerHost stellen den Klebstoff bereit, der es verschiedenen Designern ermöglicht, zusammenzuarbeiten.

Die DesignerSerializationManager Klasse implementiert IDesignerSerializationManager. Es wurde entwickelt, um eine generische Form der Deserialisierung bereitzustellen, die den Laufzeit serialisierern wie der BinaryFormatter.

Die DesignerSerializationManager Klasse erreicht drei Ziele:

• Es handelt sich um ein einfaches, turnkey-Objekt, das zum Deserialisieren einer Vielzahl von Formaten verwendet werden kann.

• Es ist generisch und nicht an ein bestimmtes Format gebunden. Sie kann auch für die CodeDOM-Deserialisierung sowie für die Markup-Deserialisierung verwendet werden.

• Es ist erweiterbar und unterstützt verschiedene Serialisierungsmethoden, die in Kopier-/Einfüge- und Rückgängig-/Wiederholen-Szenarien verwendet werden.

Die Entwurfszeit-Serialisierung unterscheidet sich von der Serialisierung des Laufzeitobjekts:

• Das Objekt, das die Serialisierung ausführt, ist in der Regel vom Laufzeitobjekt getrennt, sodass Entwurfszeitlogik aus einer Komponente entfernt werden kann.

• Das Serialisierungsschema setzt voraus, dass das Objekt vollständig initialisiert und dann durch Eigenschaften- und Methodenaufrufe während der Deserialisierung geändert wird.

• Eigenschaften eines Objekts mit Werten, die nie für das Objekt festgelegt wurden (die Eigenschaften enthalten die Standardwerte), werden nicht serialisiert. Umgekehrt kann der Deserialisierungsstrom Löcher aufweisen.

• Der Schwerpunkt liegt auf der Qualität des Inhalts innerhalb des Serialisierungsstreams und nicht auf der vollständigen Serialisierung eines Objekts. Dies bedeutet, dass, wenn es keine definierte Methode zum Serialisieren eines Objekts gibt, dieses Objekt möglicherweise übersprungen wird, anstatt eine Ausnahme auszuwerfen. Das Serialisierungsmodul kann hier Heuristiken bereitstellen, um zu entscheiden, welche Fehler ignoriert werden können und welche nicht wiederhergestellt werden können.

• Der Serialisierungsstream enthält möglicherweise mehr Daten als für die Deserialisierung erforderlich ist. Die Serialisierung des Quellcodes enthält z. B. einen Gemischten Benutzercode mit dem Code, der zum Deserialisieren eines Objektdiagramms erforderlich ist. Dieser Benutzercode muss bei der Deserialisierung ignoriert und bei der Serialisierung beibehalten werden.

Aufgrund dieser Unterschiede gilt ein anderes Serialisierungsmodell für die Entwurfszeit-Serialisierung. Dieses Modell verwendet ein separates Serialisierungsobjekt für jeden Datentyp, der serialisiert wird. Jeder Serialisierer leistet seinen kleinen Beitrag zum Problem insgesamt. Diese Serialisierer werden alle über einen gemeinsamen Serialisierungs-Manager koordiniert. Der Serialisierungs-Manager ist für die Aufrechterhaltung des Zustands zwischen diesen verschiedenen Serialisierern verantwortlich. Betrachten Sie beispielsweise die folgende Klasse:

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

Eine Instanz dieser Klasse würde drei verschiedene Serialisierer verwenden: eine für SampleObject, eine für Zeichenfolgen und eine für ganze Zahlen. The serializer for SampleObject is called the root serializer because SampleObject is the root of the serialization graph. Komplexere Objektdiagramme können ebenfalls erstellt werden. Überlegen Sie beispielsweise, was passiert, wenn SampleObject sie wie folgt geändert würden:

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

Dadurch kann SampleObject ein untergeordnetes Element vorhanden sein, das eine andere Instanz von sich selbst ist. Der folgende Code füllt das Objektdiagramm aus:

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

Wenn root serialisiert wird, werden vier Serialisierer verwendet: ein Stamm-Serialisierer, ein Serialisierer für das untergeordnete Element SampleObject, ein Serialisierer für intund ein Serialisierer für string. Serialisierer werden basierend auf dem Typ zwischengespeichert, daher ist es nicht erforderlich, für jede Instanz von SampleObject.

Die DesignerSerializationManager Klasse basiert auf der Idee einer Serialisierungssitzung. Eine Sitzung verwaltet den Zustand, auf den von den verschiedenen Serialisierern zugegriffen werden kann. Wenn eine Sitzung verworfen wird, wird dieser Zustand zerstört. Dadurch können Sie sicherstellen, dass Serialisierer weitgehend zustandslos bleiben und Serialisierer bereinigen können, die beschädigt wurden. In den folgenden Tabellen wird beschrieben, wie der Zustand in und zwischen Sitzungen verwaltet wird.

Globaler Status

Dieser Zustand gehört dem Serialisierungs-Manager-Objekt, ist jedoch unabhängig von der aktuellen Serialisierungssitzung.

Session-Owned Staat

Dieser Zustand gehört einer Sitzung und wird zerstört, wenn eine Sitzung zerstört wird. Folglich löst der Zugriff auf eigenschaften oder Methoden, die diesen Zustand bearbeiten würden, eine Ausnahme aus, wenn sich der Serialisierungs-Manager nicht in einer aktiven Sitzung befindet.

Weitere Informationen

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider