DesignerSerializationManager Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Fournit une implémentation de l’interface IDesignerSerializationManager.
public ref class DesignerSerializationManager : IServiceProvider, System::ComponentModel::Design::Serialization::IDesignerSerializationManagerpublic class DesignerSerializationManager : IServiceProvider, System.ComponentModel.Design.Serialization.IDesignerSerializationManagertype DesignerSerializationManager = class
interface IDesignerSerializationManager
interface IServiceProviderPublic 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. |
