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 zu einem Objekt konzipiert, das die Serialisierung steuert. Es stellt im Wesentlichen Kontext und Dienste für Serialisierer bereit, die die Deserialisierung tatsächlich ausführen. IDesignerSerializationManager unterstützt den Deserialisierungsprozess, indem objekte nachverfolgt werden. Dies ähnelt in 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 Laufzeitserialisierungen wie den BinaryFormatterähnelt.

Die DesignerSerializationManager Klasse erreicht drei Ziele:

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

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

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

Die Entwurfszeitserialisierung unterscheidet sich von der Serialisierung von Laufzeitobjekten:

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

• Das Serialisierungsschema setzt voraus, dass das Objekt vollständig initialisiert und dann während der Deserialisierung durch Aufrufe von Eigenschaften und Methoden 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 Serialisierungsdatenstroms und nicht auf der vollständigen Serialisierung eines Objekts. Dies bedeutet, dass, wenn es keine definierte Möglichkeit zum Serialisieren eines Objekts gibt, dieses Objekt möglicherweise übersprungen wird, anstatt eine Ausnahme auszulösen. Die Serialisierungs-Engine kann hier Heuristiken bereitstellen, um zu entscheiden, welche Fehler ignoriert werden können und welche nicht behebbar sind.

• Der Serialisierungsdatenstrom enthält möglicherweise mehr Daten, als für die Deserialisierung benötigt wird. Bei der Quellcodeserialisierung wird beispielsweise Der Benutzercode mit dem Code gemischt, der zum Deserialisieren eines Objektgraphen benötigt wird. Dieser Benutzercode muss bei der Deserialisierung ignoriert und bei der Serialisierung beibehalten werden.

Aufgrund dieser Unterschiede gilt ein anderes Serialisierungsmodell für die Entwurfszeitserialisierung. Dieses Modell verwendet ein separates Serialisierungsobjekt für jeden Datentyp, der serialisiert wird. Jedes Serialisierungsprogramm leistet seinen kleinen Beitrag zum Problem als Ganzes. Diese Serialisierer werden alle über einen gemeinsamen Serialisierungs-Manager koordiniert. Der Serialisierungs-Manager ist für die Verwaltung 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

Ein instance dieser Klasse würde drei verschiedene Serialisierer verwenden: eine für SampleObject, eine für Zeichenfolgen und eine andere für ganze Zahlen. Das Serialisierungsprogramm für SampleObject wird als Stammserialisierungsprogramm bezeichnet, da SampleObject der Stamm des Serialisierungsdiagramms ist. Es können auch komplexere Objektgraphen erstellt werden. Überlegen Sie beispielsweise, was passieren würde, wenn SampleObject sie wie folgt geändert würde:

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

Dies ermöglicht SampleObject es, ein Kind zu haben, das ein weiteres instance 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 Stammserialisierungsprogramm, ein Serialisierungsprogramm für das untergeordnete SampleObjectElement, ein Serialisierungsprogramm für intund ein Serialisierungsprogramm für string. Serialisierungsprogramme werden basierend auf dem Typ zwischengespeichert, sodass es nicht erforderlich ist, ein Serialisierungsprogramm für jede instance von SampleObjectzu erstellen.

Die DesignerSerializationManager -Klasse basiert auf der Idee einer Serialisierungssitzung. Eine Sitzung verwaltet den Zustand, auf den die verschiedenen Serialisierer zugreifen können. Wenn eine Sitzung verworfen wird, wird dieser Zustand zerstört. Dies trägt dazu bei, sicherzustellen, dass Serialisierer weitgehend zustandslos bleiben, und hilft, beschädigte Serialisierer zu sauber. 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 Zustand

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.

Konstruktoren

Eigenschaften

Methoden

Ereignisse

Explizite Schnittstellenimplementierungen

Gilt für:

Weitere Informationen

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider