DesignerSerializationManager Classe

Définition

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

Héritage

Object

DesignerSerializationManager

Implémente

IDesignerSerializationManager IServiceProvider

Remarques

L’interface IDesignerSerializationManager est conçue pour être une interface indépendante du format d’un objet qui contrôle la sérialisation. Il fournit essentiellement le contexte et les services aux sérialiseurs, qui effectuent en fait la désérialisation. IDesignerSerializationManager facilite le processus de désérialisation en effectuant le suivi des objets. Cette technique est similaire à celle de l’interface IDesignerHost : les concepteurs fournissent en fait l’interface utilisateur et IDesignerHost fournissent le collage qui permet à différents concepteurs de travailler ensemble.

La classe DesignerSerializationManager implémente IDesignerSerializationManager. Il est conçu pour fournir une forme générique de désérialisation similaire aux sérialiseurs d’exécution BinaryFormattertels que .

La DesignerSerializationManager classe atteint trois objectifs :

• Il s’agit d’un objet clé en main simple qui peut être utilisé pour désérialiser divers formats.

• Il est générique et n’est lié à aucun format particulier. Il peut être utilisé également pour la désérialisation de CodeDOM et la désérialisation de balisage.

• Il est extensible et prend en charge différentes méthodes de sérialisation utilisées dans les scénarios de copie/collage et d’annulation/restauration.

La sérialisation au moment du design présente les différences suivantes par rapport à la sérialisation des objets d’exécution :

• L’objet effectuant la sérialisation est généralement distinct de l’objet d’exécution, de sorte que la logique au moment du design peut être supprimée d’un composant.

• Le schéma de sérialisation suppose que l’objet sera entièrement initialisé, puis modifié via des appels de propriété et de méthode pendant la désérialisation.

• Les propriétés d’un objet qui ont des valeurs qui n’ont jamais été définies sur l’objet (les propriétés contiennent les valeurs par défaut) ne sont pas sérialisées. À l’inverse, le flux de désérialisation peut avoir des trous.

• L’accent est mis sur la qualité du contenu dans le flux de sérialisation, plutôt que sur la sérialisation complète d’un objet. Cela signifie que s’il n’existe aucun moyen défini de sérialiser un objet, cet objet peut être ignoré au lieu de lever une exception. Le moteur de sérialisation peut fournir ici des heuristiques pour déterminer les défaillances qui peuvent être ignorées et celles qui sont irrécupérables.

• Le flux de sérialisation peut contenir plus de données que nécessaire pour la désérialisation. La sérialisation du code source, par exemple, a du code utilisateur mélangé avec le code nécessaire pour désérialiser un graphique d’objets. Ce code utilisateur doit être ignoré lors de la désérialisation et conservé lors de la sérialisation.

En raison de ces différences, un modèle de sérialisation différent s’applique à la sérialisation au moment du design. Ce modèle utilise un objet sérialiseur distinct pour chaque type de données sérialisé. Chaque sérialiseur fournit sa petite contribution au problème dans son ensemble. Ces sérialiseurs sont tous coordonnés via un gestionnaire de sérialisation commun. Le gestionnaire de sérialisation est chargé de maintenir l’état entre ces différents sérialiseurs. Prenons l’exemple de la classe suivante :

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

Une instance de cette classe utilise trois sérialiseurs différents : un pour SampleObject, un pour les chaînes et un autre pour les entiers. Le sérialiseur pour SampleObject est appelé sérialiseur racine, car SampleObject est la racine du graphique de sérialisation. Des graphiques d’objets plus complexes peuvent également être créés. Par exemple, considérez ce qui se passerait si SampleObject étaient modifiés comme suit :

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

Cela permet SampleObject d’avoir un enfant qui est un autre instance de lui-même. Le code suivant remplit le graphique d’objets :

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

Lorsque root est sérialisé, quatre sérialiseurs sont utilisés : un sérialiseur racine, un sérialiseur pour l’enfant SampleObject, un sérialiseur pour intet un sérialiseur pour string. Les sérialiseurs étant mis en cache en fonction du type, il n’est pas nécessaire de créer un sérialiseur pour chaque instance de SampleObject.

La DesignerSerializationManager classe est basée sur l’idée d’une session de sérialisation. Une session conserve l’état accessible par les différents sérialiseurs. Lorsqu’une session est supprimée, cet état est détruit. Cela permet de s’assurer que les sérialiseurs restent en grande partie sans état et de propre les sérialiseurs qui ont été endommagés. Les tableaux suivants décrivent comment l’état est géré dans et entre les sessions.

État global

Cet état appartient à l’objet gestionnaire de sérialisation, mais il est indépendant de la session de sérialisation actuelle.

état Session-Owned

Cet état appartient à une session et est détruit lorsqu’une session est détruite. Par conséquent, l’accès à des propriétés ou méthodes qui manipuleraient cet état lève une exception si le gestionnaire de sérialisation ne se trouve pas dans une session active.

Constructeurs

Propriétés

Méthodes

Événements

Implémentations d’interfaces explicites

S’applique à

Voir aussi

• IDesignerSerializationManager
• IDesignerHost
• ContextStack
• IServiceProvider