Sérialisation et stockage de documents

Article
06/02/2023

Microsoft .NET Framework fournit un environnement puissant pour la création et l’affichage de documents de haute qualité. Les fonctionnalités améliorées qui prennent en charge les documents fixes et les documents de flux, les contrôles d’affichage avancés, combinées à de puissantes fonctionnalités graphiques 2D et 3D, prennent les applications .NET Framework à un nouveau niveau de qualité et d’expérience utilisateur. La possibilité de gérer de manière flexible une représentation en mémoire d’un document est une fonctionnalité clé de .NET Framework et de pouvoir enregistrer et charger efficacement des documents à partir d’un magasin de données est un besoin de presque toutes les applications. Le processus de conversion d’un document d’une représentation en mémoire interne en magasin de données externe est appelé sérialisation. Le processus inverse consistant à lire un magasin de données et à recréer l’instance en mémoire d’origine est appelé désérialisation.

À 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 dans un format différent. Par exemple, une application peut proposer des options « Enregistrer sous » pour stocker 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 ou 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 les avantages de l’encapsulation des détails de stockage, les API .NET Framework System.Windows.Documents.Serialization fournissent 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 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 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 une utilisation par toutes les applications .NET Framework.
- Découvertibilité 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'impression XPS

Le chemin d’impression DE MICROSOFT .NET Framework XPS fournit également un mécanisme extensible permettant d’écrire des documents via la sortie d’impression. XPS sert à la fois de format de fichier de document et est le format de pool d’impression natif pour Windows Vista. Les documents XPS peuvent être envoyés directement aux imprimantes compatibles XPS sans avoir besoin de convertir en 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 System.Windows.Documents.Serialization API prennent en charge les sérialiseurs plug-in et les sérialiseurs liés installés séparément de l’application, liez au moment de l’exécution et sont accessibles à l’aide du SerializerProvider mécanisme de découverte. Les sérialiseurs de plug-ins simplifient grandement les déploiements et les utilisations à l’échelle du système. Les sérialiseurs liés peuvent également être implémentés pour des environnements de confiance partielle tels que les applications de navigateur XAML (XBAPs) où les sérialiseurs de plug-in ne sont pas accessibles. Les sérialiseurs liés, basés sur une implémentation dérivée de la SerializerWriter classe, 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 nouvelles conceptions de stockage et aux nouveaux 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 SerializerProvider classe énumère un SerializerDescriptor objet pour chaque plug-in installé sur le système. La IsLoadable propriété 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. Il SerializerDescriptor fournit également d’autres propriétés, telles que DisplayName et DefaultFileExtension, que l’application peut utiliser pour inviter l’utilisateur à sélectionner un sérialiseur pour un format de sortie disponible. Un sérialiseur de plug-in par défaut pour XPS est fourni avec .NET Framework et est toujours énuméré. Une fois que l’utilisateur a sélectionné un format de sortie, la CreateSerializerWriter méthode est utilisée pour créer un SerializerWriter format spécifique. La SerializerWriter.Write méthode peut ensuite être appelée pour générer le flux de documents dans le magasin de données.

L’exemple suivant illustre une application qui utilise la SerializerProvider méthode dans une propriété « PlugInFileFilter ». PlugInFileFilter énumère les plug-ins installés et génère une chaîne de filtre avec les options de fichier disponibles pour un 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;
    }
}

Une fois qu’un nom de fichier de sortie a été sélectionné par l’utilisateur, l’exemple suivant illustre l’utilisation de la CreateSerializerWriter méthode pour stocker un document donné dans un format spécifié.

// 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 SerializerProvider classe fournit l’interface d’application de niveau supérieur pour la découverte et l’accès du sérialiseur plug-in. 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 à l’aide des paramètres du Registre. Les sérialiseurs de plug-in peuvent être ajoutés au Registre à l’aide de la RegisterSerializer méthode ; ou si .NET Framework n’est pas encore installé, le script d’installation du plug-in peut définir directement les valeurs de Registre elle-même. La UnregisterSerializer méthode peut être utilisée pour supprimer un plug-in précédemment installé, ou les paramètres de Registre peuvent être réinitialisés de la même façon par un script de désinstallation.

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 de test permet d’accéder aux points d’arrêt et autres services de débogage utiles lors du test.
Une fois que le sérialiseur est entièrement testé, une ISerializerFactory interface est ajoutée pour créer un plug-in. L’interface ISerializerFactory permet un accès total à tous les objets .NET Framework qui incluent l’arborescence logique, UIElement les objets IDocumentPaginatorSourceet Visual les éléments. Fournit également ISerializerFactory les mêmes méthodes et événements synchrones et asynchrones 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).