DesignerSerializationManager Klass

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

Arv

Object

DesignerSerializationManager

Implementeringar

IDesignerSerializationManager IServiceProvider

Kommentarer

Gränssnittet IDesignerSerializationManager är utformat för att vara ett formatoberoende gränssnitt till ett objekt som styr serialisering. Det ger i princip kontext och tjänster till serialiserare, som faktiskt utför deserialiseringen. IDesignerSerializationManager hjälper till med deserialiseringsprocessen genom att hålla reda på objekt. Detta liknar tekniken IDesignerHost i gränssnittet: designers tillhandahåller faktiskt användargränssnittet (UI) och IDesignerHost tillhandahåller limmet som gör att olika designers kan arbeta tillsammans.

Klassen DesignerSerializationManager implementerar IDesignerSerializationManager. Den är utformad för att ge en allmän form av deserialisering som liknar run-time-serialiserare som BinaryFormatter.

Klassen DesignerSerializationManager uppnår tre mål:

• Det är ett enkelt nyckelfärdigt objekt som kan användas för att deserialisera en mängd olika format.

• Det är generiskt och inte kopplat till något visst format. Det kan användas lika för CodeDOM-deserialisering samt markeringsdeserialisering.

• Den är utökningsbar och stöder olika serialiseringsmetoder som används i scenarier för att kopiera/klistra in och ångra/göra om.

Designtidsserialisering har följande skillnader jämfört med serialisering av körningsobjekt:

• Objektet som utför serialiseringen är vanligtvis skilt från körningsobjektet, så att designtidslogik kan tas bort från en komponent.

• Serialiseringsschemat förutsätter att objektet kommer att skapas helt initierat och sedan ändras via egenskaps- och metodanrop under deserialisering.

• Egenskaper för ett objekt som har värden som aldrig har angetts för objektet (egenskaperna innehåller standardvärdena) serialiseras inte. Omvänt kan deserialiseringsströmmen ha hål.

• Fokus läggs på innehållets kvalitet i serialiseringsströmmen i stället för den fullständiga serialiseringen av ett objekt. Det innebär att om det inte finns något definierat sätt att serialisera ett objekt kan det objektet hoppas över i stället för att utlösa ett undantag. Serialiseringsmotorn kan tillhandahålla heuristik här för att avgöra vilka fel som kan ignoreras och vilka som inte kan återställas.

• Serialiseringsströmmen kan ha mer data än vad som behövs för deserialisering. Källkodsserialisering har till exempel användarkod blandat med den kod som behövs för att deserialisera ett objektdiagram. Den här användarkoden måste ignoreras vid deserialisering och bevaras vid serialisering.

På grund av dessa skillnader gäller en annan serialiseringsmodell för seriell designtid. Den här modellen använder ett separat serialiserarobjekt för varje datatyp som serialiseras. Varje serialiserare ger sitt lilla bidrag till problemet som helhet. Alla dessa serialiserare koordineras via en gemensam serialiseringshanterare. Serialiseringshanteraren ansvarar för att upprätthålla tillståndet mellan dessa olika serialiserare. Tänk till exempel på följande klass:

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

En instans av den här klassen skulle använda tre olika serialiserare: en för SampleObject, en för strängar och en annan för heltal. Serialiseraren för SampleObject kallas rot-serialiseraren eftersom SampleObject är roten i serialiseringsdiagrammet. Mer komplexa objektdiagram kan också skapas. Tänk till exempel på vad som skulle hända om SampleObject det ändrades på följande sätt:

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

Detta gör det möjligt SampleObject att ha ett underordnat objekt som är en annan instans av sig själv. Följande kod fyller i objektdiagrammet:

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

När root serialiseras används fyra serialiserare: en rotserialiserare, en serialiserare för det underordnade SampleObject, en serialiserare för intoch en serialiserare för string. Serialiserare cachelagras baserat på typ, så du behöver inte skapa en serialiserare för varje instans av SampleObject.

Klassen DesignerSerializationManager baseras på idén om en serialiseringssession. En session upprätthåller tillstånd som kan nås av de olika serialiserarna. När en session tas bort förstörs det här tillståndet. Detta hjälper till att säkerställa att serialiserare förblir i stort sett tillståndslösa och hjälper till att rensa serialiserare som har skadats. I följande tabeller beskrivs hur tillstånd hanteras i och bland sessioner.

Globalt tillstånd

Det här tillståndet ägs av serialiseringshanterarens objekt, men är oberoende av den aktuella serialiseringssessionen.

Session-Owned tillstånd

Det här tillståndet ägs av en session och förstörs när en session förstörs. Därför utlöser åtkomst till alla egenskaper eller metoder som skulle manipulera det här tillståndet ett undantag om serialiseringshanteraren inte är i en aktiv session.

Se även

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider