DesignerSerializationManager Klas

Definitie

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

Overname

Object

DesignerSerializationManager

Implementeringen

IDesignerSerializationManager IServiceProvider

Opmerkingen

De IDesignerSerializationManager interface is ontworpen als een indelingsonafhankelijke interface voor een object dat serialisatie regelt. Het biedt in wezen context en services aan serializers, die daadwerkelijk deserialisatie uitvoeren. IDesignerSerializationManager helpt bij het deserialisatieproces door objecten bij te houden. Dit is vergelijkbaar met de IDesignerHost interface: ontwerpers bieden de gebruikersinterface (UI) en IDesignerHost bieden de lijm waarmee verschillende ontwerpers kunnen samenwerken.

De DesignerSerializationManager klasse implementeert IDesignerSerializationManager. Het is ontworpen om een algemene vorm van deserialisatie te bieden die vergelijkbaar is met runtime-serializers zoals de BinaryFormatter.

De DesignerSerializationManager klasse bereikt drie doelen:

• Het is een eenvoudig, kant-en-klare object dat kan worden gebruikt om verschillende indelingen te deserialiseren.

• Het is algemeen en niet gekoppeld aan een bepaalde indeling. Het kan ook worden gebruikt voor codeDOM-deserialisatie en voor deserialisatie van markeringen.

• Het is uitbreidbaar en ondersteunt verschillende serialisatiemethoden die worden gebruikt in scenario's voor kopiëren/plakken en ongedaan maken/opnieuw uitvoeren.

Ontwerptijdserialisatie heeft de volgende verschillen ten tijde van de serialisatie van runtimeobjecten:

• Het object dat de serialisatie uitvoert, is over het algemeen gescheiden van het runtime-object, zodat ontwerptijdlogica uit een onderdeel kan worden verwijderd.

• In het serialisatieschema wordt ervan uitgegaan dat het object volledig wordt geïnitialiseerd en vervolgens wordt gewijzigd via eigenschaps- en methodeaanroepen tijdens deserialisatie.

• Eigenschappen van een object met waarden die nooit op het object zijn ingesteld (de eigenschappen bevatten de standaardwaarden) worden niet geserialiseerd. Omgekeerd kan de deserialisatiestroom gaten hebben.

• Nadruk wordt gelegd op de kwaliteit van de inhoud binnen de serialisatiestroom, in plaats van de volledige serialisatie van een object. Dit betekent dat als er geen gedefinieerde manier is om een object te serialiseren, dat object kan worden overgeslagen in plaats van een uitzondering te genereren. De serialisatie-engine kan hier heuristieken bieden om te bepalen welke fouten kunnen worden genegeerd en welke onherstelbaar zijn.

• De serialisatiestroom kan meer gegevens bevatten dan nodig is voor deserialisatie. Broncodeserialisatie heeft bijvoorbeeld gebruikerscode gemengd met de code die nodig is om een objectgrafiek te deserialiseren. Deze gebruikerscode moet worden genegeerd bij deserialisatie en bewaard blijven bij serialisatie.

Vanwege deze verschillen is een ander serialisatiemodel van toepassing op ontwerptijdserialisatie. Dit model maakt gebruik van een afzonderlijk serialisatieobject voor elk gegevenstype dat wordt geserialiseerd. Elke serializer levert zijn kleine bijdrage aan het probleem als geheel. Deze serialisatieprogramma's worden allemaal gecoördineerd via een algemeen serialisatiebeheer. De serialisatiemanager is verantwoordelijk voor het onderhouden van de status tussen deze verschillende serializers. Bekijk bijvoorbeeld de volgende 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

Een exemplaar van deze klasse maakt gebruik van drie verschillende serializers: een voor, een voor SampleObjecttekenreeksen en een andere voor gehele getallen. De serializer voor SampleObject wordt de hoofdserialisatie genoemd omdat SampleObject dit de hoofdmap van de serialisatiegrafiek is. Complexere objectgrafieken kunnen ook worden gemaakt. Denk bijvoorbeeld na wat er zou gebeuren als SampleObject deze als volgt zijn gewijzigd:

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

Dit maakt het mogelijk SampleObject om een kind te hebben dat een ander exemplaar van zichzelf is. De volgende code vult de objectgrafiek in:

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

Wanneer root wordt geserialiseerd, worden er vier serializers gebruikt: één hoofdserialisatie, één serialisatiefunctie voor het kind SampleObject, één serializer voor inten één serializer voor string. Serializers worden opgeslagen in de cache op basis van het type, dus er is geen serialisatiefunctie nodig voor elk exemplaar van SampleObject.

De DesignerSerializationManager klasse is gebaseerd op het idee van een serialisatiesessie. Een sessie behoudt de status die toegankelijk is voor de verschillende serializers. Wanneer een sessie wordt verwijderd, wordt deze status vernietigd. Dit helpt ervoor te zorgen dat serializers grotendeels staatloos blijven en helpt bij het opschonen van serializers die zijn beschadigd. In de volgende tabellen wordt beschreven hoe de status wordt beheerd in en tussen sessies.

Globale status

Deze status is eigendom van het serialisatiebeheerobject, maar is onafhankelijk van de huidige serialisatiesessie.

Session-Owned staat

Deze status is eigendom van een sessie en wordt vernietigd wanneer een sessie wordt vernietigd. Als u dus toegang wilt krijgen tot eigenschappen of methoden die deze status zouden manipuleren, treedt er een uitzondering op als de serialisatiemanager zich niet in een actieve sessie bevindt.

Zie ook

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider