Sérialisation et stockage de documents
Mise à jour : novembre 2007
Microsoft .NET Framework fournit un environnement puissant pour créer et afficher des documents de haute qualité. Grâce à des fonctionnalités améliorées prenant en charge les documents fixes comme les documents dynamiques, des contrôles d'affichage avancés et des fonctions graphiques 2D et 3D puissantes, les applications .NET Framework offrent un niveau de qualité et une expérience utilisateur inégalés. La possibilité de gérer une représentation en mémoire d'un document de manière flexible est une fonctionnalité clé de .NET Framework ; en outre, la quasi-totalité des applications requièrent de pouvoir enregistrer et charger efficacement des documents d'un magasin de données. Le processus de conversion d'un document d'une représentation en mémoire interne en un magasin de données externes est nommé sérialisation. Le processus inverse de lecture d'un magasin de données et de recréation de l'instance en mémoire d'origine est appelé désérialisation.
Cette rubrique comprend les sections suivantes.
- À propos de la sérialisation de documents
- Sérialiseurs de plug-ins
- Rubriques connexes
À propos de la sérialisation de documents
Dans l'idéal, les processus de sérialisation et de désérialisation d'un document depuis et vers la mémoire sont transparents pour l'application. L'application appelle une méthode de sérialiseur « en écriture » pour enregistrer le document, tandis qu'une méthode de désérialiseur « en lecture » accède au magasin de données pour recréer l'instance d'origine en mémoire. Le format spécifique de stockage des données ne concerne généralement pas l'application tant que les processus de sérialisation et de désérialisation recréent le document d'origine.
Les applications fournissent souvent plusieurs options de sérialisation qui permettent à l'utilisateur d'enregistrer des documents sur différents médias ou sous un format différent. Par exemple, une application peut proposer des options « Enregistrer sous » pour le stockage d'un document dans un fichier sur disque, une base de données ou un service Web. De même, différents sérialiseurs peuvent stocker le document sous divers formats, tels que les formats HTML, RTF, XML, XPS ou encore un format tiers. Pour l'application, la sérialisation définit une interface qui isole les détails du média de stockage dans l'implémentation de chaque sérialiseur spécifique. Outre l'avantage d'encapsuler les détails de stockage, les API.NET FrameworkSystem.Windows.Documents.Serialization fournissent également plusieurs autres fonctionnalités importantes.
Fonctionnalités des sérialiseurs de documents .NET Framework 3.0
L'accès direct aux objets de document de niveau supérieur (arborescence logique et objets visuels) permet un stockage efficace de contenu paginé, d'éléments 2D/3D, d'images, de fichiers multimédias, de liens hypertexte, d'annotations et d'autre contenu de support.
Fonctionnement synchrone et asynchrone.
Prise en charge de sérialiseurs de plug-ins avec fonctionnalités améliorées :
Accès à l'échelle du système pour toutes les applications .NET Framework ;
Détectabilité de plug-ins d'application simplifiée ;
Déploiement, installation et mise à jour simples pour les plug-ins tiers personnalisés ;
Prise en charge des paramètres et des options d'exécution personnalisés par l'interface utilisateur.
Chemin d'accès d'impression XPS
Le chemin d'accès d'impression XPS de Microsoft .NET Framework fournit également un mécanisme extensible pour l'écriture de documents par impression. Le format XPS est utilisé comme format de fichier document et comme format natif de mise en attente d'impression pour Windows Vista. Ainsi, les documents XPS peuvent être envoyés directement aux imprimantes compatibles XPS sans qu'il soit nécessaire de les convertir en un format intermédiaire. Consultez la rubrique Vue d'ensemble de l'impression pour obtenir des informations supplémentaires sur les options et les fonctionnalités de chemin d'impression.
Sérialiseurs de plug-ins
Les API System.Windows.Documents.Serialization offrent une prise en charge des sérialiseurs de plug-ins et des sérialiseurs liés installés séparément de l'application ; elles effectuent une liaison au moment de l'exécution et sont accessibles via le mécanisme de découverte SerializerProvider. Les sérialiseurs de plug-ins offrent des améliorations considérables pour un déploiement simplifié et une utilisation à l'échelle du système. Les sérialiseurs liés peuvent également être implémentés pour les environnements de confiance partielle tels que les applications du navigateur XAML (XBAP) dans lesquelles les sérialiseurs de plug-ins ne sont pas accessibles. Les sérialiseurs liés, basés sur une implémentation dérivée de la classe SerializerWriter, sont compilés et liés directement dans l'application. Les sérialiseurs de plug-ins comme les sérialiseurs liés fonctionnent selon des méthodes et des événements publics identiques qui facilitent leur utilisation séparée ou simultanée dans la même application.
Les sérialiseurs de plug-ins aident les développeurs d'applications en fournissant une extensibilité aux nouveaux types de stockage et formats de fichiers sans nécessiter de codage direct pour chaque format potentiel au moment de la génération. Ils représentent également un atout pour les développeurs tiers, qui bénéficient ainsi d'un moyen standardisé pour déployer, installer et mettre à jour les plug-ins système accessibles pour les formats de fichiers personnalisés ou propriétaires.
Utilisation d'un sérialiseur de plug-ins
Les sérialiseurs de plug-ins sont simples à utiliser. La classe SerializerProvider énumère un objet SerializerDescriptor pour chaque plug-in installé sur le système. La propriété IsLoadable filtre les plug-ins installés en fonction de la configuration actuelle et vérifie que le sérialiseur peut être chargé et utilisé par l'application. La classe SerializerDescriptor fournit également d'autres propriétés, telles que les propriétés DisplayName et DefaultFileExtension, que l'application peut utiliser afin d'inviter l'utilisateur à sélectionner un sérialiseur pour un format de sortie disponible. Un sérialiseur de plug-ins par défaut pour le format XPS est fourni avec .NET Framework et est toujours énuméré. Une fois le format de sortie sélectionné par l'utilisateur, la méthode CreateSerializerWriter est utilisée pour créer une classe SerializerWriter pour le format spécifique. La méthode SerializerWriter.Write peut alors être appelée pour la sortie du flux de données du document dans le magasin de données.
L'exemple suivant montre une application qui utilise la méthode SerializerProvider dans une propriété « PlugInFileFilter ». La propriété PlugInFileFilter énumère les plug-ins installés et génère une chaîne de filtrage avec les options de fichier disponibles pour une classe SaveFileDialog.
// ------------------------ PlugInFileFilter --------------------------
/// <summary>
/// Gets a filter string for installed plug-in serializers.</summary>
/// <remark>
/// PlugInFileFilter is used to set the SaveFileDialog or
/// OpenFileDialog "Filter" property when saving or opening files
/// using plug-in serializers.</remark>
private string PlugInFileFilter
{
get
{ // Create a SerializerProvider for accessing plug-in serializers.
SerializerProvider serializerProvider = new SerializerProvider();
string filter = "";
// For each loadable serializer, add its display
// name and extension to the filter string.
foreach (SerializerDescriptor serializerDescriptor in
serializerProvider.InstalledSerializers)
{
if (serializerDescriptor.IsLoadable)
{
// After the first, separate entries with a "|".
if (filter.Length > 0) filter += "|";
// Add an entry with the plug-in name and extension.
filter += serializerDescriptor.DisplayName + " (*" +
serializerDescriptor.DefaultFileExtension + ")|*" +
serializerDescriptor.DefaultFileExtension;
}
}
// Return the filter string of installed plug-in serializers.
return filter;
}
}
L'exemple suivant montre comment utiliser la méthode CreateSerializerWriter pour stocker un document donné dans un format spécifié, une fois le fichier de sortie nommé par l'utilisateur. Pour accéder à l'intégralité de l'exemple, consultez la rubrique Sérialisation de documents, exemple.
// Create a SerializerProvider for accessing plug-in serializers.
SerializerProvider serializerProvider = new SerializerProvider();
// Locate the serializer that matches the fileName extension.
SerializerDescriptor selectedPlugIn = null;
foreach ( SerializerDescriptor serializerDescriptor in
serializerProvider.InstalledSerializers )
{
if ( serializerDescriptor.IsLoadable &&
fileName.EndsWith(serializerDescriptor.DefaultFileExtension) )
{ // The plug-in serializer and fileName extensions match.
selectedPlugIn = serializerDescriptor;
break; // foreach
}
}
// If a match for a plug-in serializer was found,
// use it to output and store the document.
if (selectedPlugIn != null)
{
Stream package = File.Create(fileName);
SerializerWriter serializerWriter =
serializerProvider.CreateSerializerWriter(selectedPlugIn,
package);
IDocumentPaginatorSource idoc =
flowDocument as IDocumentPaginatorSource;
serializerWriter.Write(idoc.DocumentPaginator, null);
package.Close();
return true;
}
Installation de sérialiseurs de plug-ins
La classe SerializerProvider fournit une interface d'application supérieure permettant la découverte et l'accès des sérialiseurs de plug-ins. La classe SerializerProvider localise et fournit à l'application une liste des sérialiseurs installés et accessibles sur le système. Les caractéristiques des sérialiseurs installés sont définies via les paramètres du Registre. Les sérialiseurs de plug-ins peuvent être ajoutés au Registre par la méthode RegisterSerializer ; si .NET Framework n'est pas encore installé, le script d'installation de plug-ins peut définir lui-même directement les valeurs de Registre. La méthode UnregisterSerializer peut être utilisée pour supprimer un plug-in installé précédemment, ou un script de désinstallation peut réinitialiser, de manière identique, les paramètres du Registre.
Création d'un sérialiseur de plug-ins
Les sérialiseurs de plug-ins et les sérialiseurs liés utilisent les mêmes méthodes et événements publics exposés et sont conçus pour un fonctionnement synchrone ou asynchrone. La création d'un sérialiseur de plug-ins se déroule généralement en trois étapes principales :
La première étape consiste à implémenter et à déboguer le sérialiseur comme sérialiseur lié. Le fait de créer un sérialiseur compilé et lié directement dans une application test permet d'accéder aux points d'arrêt et autres services de débogage utiles lors du test.
Une fois le sérialiseur intégralement testé, une interface ISerializerFactory est ajoutée pour créer un plug-in. L'interface ISerializerFactory autorise un accès complet à tous les objets .NET Framework, notamment à l'arborescence logique, aux objets UIElement, IDocumentPaginatorSourceet aux éléments Visual. En outre, l'interface ISerializerFactory fournit les mêmes méthodes et événements synchrones et asynchrones que ceux utilisés par les sérialiseurs liés. La sortie des documents volumineux pouvant prendre un certain temps, un fonctionnement asynchrone est recommandé de sorte à maintenir la réactivité de l'intervention de l'utilisateur tout en offrant une option « Annuler » en cas de problème avec le magasin de données.
Une fois le sérialiseur de plug-ins créé, un script d'installation est implémenté pour distribuer et installer (ou désinstaller) le plug-in (voir la section ci-dessus intitulée « Installation de sérialiseurs de plug-ins »).
Voir aussi
Tâches
Sérialisation de documents, exemple
Concepts
Documents dans Windows Presentation Foundation
Vue d'ensemble de l'impression
Référence
System.Windows.Documents.Serialization