Partage via


DesignerSerializationManager Classe

Définition

Fournit une implémentation de l’interface IDesignerSerializationManager.

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
DesignerSerializationManager
Implémente

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.

Objet Utilisation
Fournisseurs de sérialisation Les objets peuvent s’ajouter eux-mêmes en tant que fournisseurs de sérialisation personnalisés. Étant donné que ces fournisseurs sont utilisés pour localiser les sérialiseurs, ils survivent à une session de sérialisation.

é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.

Objet Utilisation
ÉvénementResolveName L’événement ResolveName est joint par un sérialiseur pour fournir une résolution supplémentaire des noms. Tous les gestionnaires sont détachés de cet événement lorsqu’une session se termine.
ÉvénementSerializationComplete L’événement SerializationComplete est déclenché juste avant la suppression d’une session. Ensuite, tous les gestionnaires sont détachés de cet événement.
Table de noms Le gestionnaire de sérialisation gère une table qui mappe entre les objets et leurs noms. Les sérialiseurs peuvent donner des noms d’objets pour faciliter leur identification. Cette table de noms est effacée à l’arrêt de la session.
Cache sérialiseur Le gestionnaire de sérialisation gère un cache de sérialiseurs qu’il a été invité à fournir. Ce cache est effacé à l’arrêt de la session. La méthode publique GetSerializer peut être appelée en toute sécurité à tout moment, mais sa valeur est mise en cache uniquement si elle est appelée à partir d’une session.
Pile de contexte Le gestionnaire de sérialisation gère un objet appelé pile de contexte, auquel vous pouvez accéder avec la Context propriété . Les sérialiseurs peuvent utiliser cette pile pour stocker des informations supplémentaires disponibles pour d’autres sérialiseurs. Par exemple, un sérialiseur qui sérialise une valeur de propriété peut envoyer (push) le nom de la propriété sur la pile de sérialisation avant de demander à la valeur de sérialiser. Cette pile est effacée lorsque la session est terminée.
Liste d'erreurs Le gestionnaire de sérialisation tient à jour une liste des erreurs qui se sont produites pendant la sérialisation. Cette liste, accessible via la Errors propriété , est effacée à l’arrêt de la session. L’accès à la Errors propriété entre les sessions entraîne une exception.

Constructeurs

DesignerSerializationManager()

Initialise une nouvelle instance de la classe DesignerSerializationManager.

DesignerSerializationManager(IServiceProvider)

Initialise une nouvelle instance de la classe DesignerSerializationManager avec le fournisseur de services donné.

Propriétés

Container

Obtient ou définit le conteneur pour ce gestionnaire de sérialisation.

Errors

Obtient la liste d'erreurs qui se sont produites pendant une sérialisation ou une désérialisation.

PreserveNames

Obtient ou définit une valeur qui indique si la méthode CreateInstance(Type, ICollection, String, Boolean) doit vérifier la présence du nom donné dans le conteneur.

PropertyProvider

Obtient l'objet qui doit être utilisé pour fournir des propriétés à la propriété Properties du gestionnaire de sérialisation.

RecycleInstances

Obtient ou définit une valeur qui indique si CreateInstance(Type, ICollection, String, Boolean) créera toujours une nouvelle instance d’un type.

ValidateRecycledTypes

Obtient ou définit une valeur qui indique si la méthode CreateInstance(Type, ICollection, String, Boolean) vérifie que les noms correspondants font référence au même type.

Méthodes

CreateInstance(Type, ICollection, String, Boolean)

Crée une instance d'un type.

CreateSession()

Crée une nouvelle session de sérialisation.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetRuntimeType(String)

Obtient le type correspondant au nom de type spécifié.

GetSerializer(Type, Type)

Obtient le sérialiseur pour le type d'objet donné.

GetService(Type)

Obtient le service demandé.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
GetType(String)

Obtient le type demandé.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
OnResolveName(ResolveNameEventArgs)

Déclenche l’événement ResolveName.

OnSessionCreated(EventArgs)

Déclenche l’événement SessionCreated.

OnSessionDisposed(EventArgs)

Déclenche l’événement SessionDisposed.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Événements

SessionCreated

Se produit lors de la création d'une session.

SessionDisposed

Se produit lors de la suppression d'une session.

Implémentations d’interfaces explicites

IDesignerSerializationManager.AddSerializationProvider(IDesignerSerializationProvider)

Ajoute un fournisseur de sérialisation personnalisé au gestionnaire de sérialisation.

IDesignerSerializationManager.Context

Obtient la pile de contexte pour cette session de sérialisation.

IDesignerSerializationManager.CreateInstance(Type, ICollection, String, Boolean)

Implémente la méthode CreateInstance(Type, ICollection, String, Boolean).

IDesignerSerializationManager.GetInstance(String)

Récupère une instance d'un objet créé du nom spécifié.

IDesignerSerializationManager.GetName(Object)

Récupère un nom pour l'objet spécifié.

IDesignerSerializationManager.GetSerializer(Type, Type)

Obtient un sérialiseur du type demandé pour le type d'objet spécifié.

IDesignerSerializationManager.GetType(String)

Obtient un type portant le nom spécifié.

IDesignerSerializationManager.Properties

Implémente la propriété Properties.

IDesignerSerializationManager.RemoveSerializationProvider(IDesignerSerializationProvider)

Supprime un fournisseur de sérialisation précédemment ajouté.

IDesignerSerializationManager.ReportError(Object)

Utilisé pour signaler une erreur récupérable dans une sérialisation.

IDesignerSerializationManager.ResolveName

Se produit lorsque la méthode IDesignerSerializationManager.GetName(Object) ne parvient pas à trouver le nom spécifié dans la table de noms du gestionnaire de sérialisation.

IDesignerSerializationManager.SerializationComplete

Se produit lorsque la sérialisation est terminée.

IDesignerSerializationManager.SetName(Object, String)

Définit le nom de l'objet spécifié.

IServiceProvider.GetService(Type)

Pour obtenir une description de ce membre, consultez la méthode GetService(Type).

S’applique à

Voir aussi