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 réellement la désérialisation. IDesignerSerializationManager aide dans le processus de désérialisation en conservant le suivi des objets. Il s’agit d’une technique similaire à celle de l’interface IDesignerHost : les concepteurs fournissent réellement l’interface utilisateur et IDesignerHost fournissent le collage qui permet à différents concepteurs de travailler ensemble.
La DesignerSerializationManager classe implémente IDesignerSerializationManager. Il est conçu pour fournir une forme générique de désérialisation similaire aux sérialiseurs au moment de l’exécution comme le BinaryFormatter.
La DesignerSerializationManager classe atteint trois objectifs :
Il s’agit d’un objet simple et clé en main qui peut être utilisé pour désérialiser une variété de formats.
Il est générique et n’est lié à aucun format particulier. Il peut être utilisé de manière égale pour la désérialisation CodeDOM, ainsi que pour 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 d’objet au moment de l’exécution :
L’objet effectuant la sérialisation est généralement distinct de l’objet d’exécution, afin que la logique au moment du design puisse être supprimée d’un composant.
Le schéma de sérialisation suppose que l’objet est créé entièrement initialisé, puis modifié par le biais 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é plutôt que de lever une exception. Le moteur de sérialisation peut fournir ici des heuristiques pour décider quels échecs peuvent être ignorés et qui sont irrécupérables.
Le flux de sérialisation peut avoir plus de données que nécessaire pour la désérialisation. La sérialisation du code source, par exemple, comporte du code utilisateur mélangé avec le code nécessaire pour désérialiser un graphe d’objet. 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 par le biais d’un gestionnaire de sérialisation commun. Le gestionnaire de sérialisation est chargé de maintenir l’état entre ces différents sérialiseurs. Par exemple, considérez 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 , un pour SampleObjectles chaînes et un autre pour les entiers. Le sérialiseur pour SampleObject lequel il est appelé sérialiseur racine est SampleObject la racine du graphe de sérialisation. Des graphiques d’objets plus complexes peuvent également être créés. Par exemple, tenez compte de ce qui se passerait s’il SampleObject était modifié 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 une 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
Lorsqu’il root est sérialisé, il y aura quatre sérialiseurs utilisés : un sérialiseur racine, un sérialiseur pour l’enfant SampleObject, un sérialiseur pour int, et un sérialiseur pour string. Les sérialiseurs sont mis en cache en fonction du type. Il n’est donc 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 largement sans état et aident à nettoyer les sérialiseurs endommagés. Les tableaux suivants décrivent comment l’état est géré et entre les sessions.
État global
Cet état appartient à l’objet gestionnaire de sérialisation, mais est indépendant de la session de sérialisation actuelle.
| Object | 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 des 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 à toutes les propriétés ou méthodes qui manipuleraient cet état lève une exception si le gestionnaire de sérialisation n’est pas dans une session active.
| Object | Utilisation |
|---|---|
| événement ResolveName | L’événement ResolveName est attaché par un sérialiseur pour fournir une résolution supplémentaire de noms. Tous les gestionnaires sont détachés de cet événement lorsqu’une session se termine. |
| événement SerializationComplete | 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 l’identification. Cette table de noms est effacée lorsque la session se termine. |
| Cache de sérialiseur | Le gestionnaire de sérialisation gère un cache de sérialiseurs qu’il a été invité à fournir. Ce cache est effacé lorsque la session se termine. 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 gère une liste d’erreurs qui se sont produites lors de la sérialisation. Cette liste, accessible via la Errors propriété, est effacée lorsque la session est terminée. L’accès à la Errors propriété entre les sessions entraîne une exception. |
Constructeurs
| Nom | Description |
|---|---|
| DesignerSerializationManager() |
Initialise une nouvelle instance de la classe DesignerSerializationManager. |
| DesignerSerializationManager(IServiceProvider) |
Initialise une nouvelle instance de la DesignerSerializationManager classe avec le fournisseur de services donné. |
Propriétés
| Nom | Description |
|---|---|
| Container |
Obtient ou définit le conteneur pour ce gestionnaire de sérialisation. |
| Errors |
Obtient la liste des erreurs qui se sont produites lors de la sérialisation ou de la désérialisation. |
| PreserveNames |
Obtient ou définit une valeur indiquant si la CreateInstance(Type, ICollection, String, Boolean) méthode 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é du gestionnaire de Properties sérialisation. |
| RecycleInstances |
Obtient ou définit une valeur qui indique si CreateInstance(Type, ICollection, String, Boolean) la création d’une instance d’un type est toujours créée. |
| ValidateRecycledTypes |
Obtient ou définit une valeur qui indique si la méthode vérifie que les CreateInstance(Type, ICollection, String, Boolean) noms correspondants font référence au même type. |
Méthodes
| Nom | Description |
|---|---|
| CreateInstance(Type, ICollection, String, Boolean) |
Crée une instance d’un type. |
| CreateSession() |
Crée une session de sérialisation. |
| Equals(Object) |
Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object) |
| GetHashCode() |
Sert 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 la Type de l’instance actuelle. (Hérité de Object) |
| GetType(String) |
Obtient le type demandé. |
| MemberwiseClone() |
Crée une copie superficielle du Objectactuel. (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
| Nom | Description |
|---|---|
| SessionCreated |
Se produit lorsqu’une session est créée. |
| SessionDisposed |
Se produit lorsqu’une session est supprimée. |
