Sérialisation et stockage des documents

Article
12/20/2024

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 interne en mémoire en magasin de données externe est appelé sérialisation. Le processus inverse de lecture d’un magasin de données et la recréation de l’instance en mémoire d’origine est appelé désérialisation.

À propos de la sérialisation de documents

Dans l’idéal, le processus de sérialisation et de désérialisation d’un document, puis de retour en mémoire est transparent pour l’application. L’application appelle une méthode de sérialiseur « write » pour enregistrer le document, tandis qu’une méthode de désérialiseur « read » accède au magasin de données et recrée l’instance d’origine en mémoire. Le format spécifique dans lequel les données sont stockées n’est généralement pas une préoccupation de l’application tant que le processus sérialiser et désérialiser recrée le document dans son formulaire d’origine.

Les applications fournissent souvent plusieurs options de sérialisation qui permettent à l’utilisateur d’enregistrer des documents sur un support différent ou dans un autre format. Par exemple, une application peut proposer des options « Enregistrer sous » pour stocker un document dans un fichier disque, une base de données ou un service web. De même, différents sérialiseurs peuvent stocker le document dans différents formats tels que HTML, RTF, XML, XPS ou alternativement à un format tiers. Pour l’application, la sérialisation définit une interface qui isole les détails du support de stockage dans l’implémentation de chaque sérialiseur spécifique. Outre les avantages de l’encapsulation des détails du 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 haut niveau (arborescence logique et visuels) permet un stockage efficace du contenu paginé, des éléments 2D/3D, des images, des médias, des liens hypertexte, des annotations et d’autres contenus de prise en charge.
Opération 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écouverte simple de plug-ins d’application.
- 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 pour plugins

Les API System.Windows.Documents.Serialization prennent en charge les sérialisateurs de plug-in et les sérialisateurs liés qui sont installés séparément de l'application, liés au moment de l'exécution et accessibles en utilisant le mécanisme de découverte SerializerProvider. Les sérialiseurs de plug-in offrent des avantages améliorés pour faciliter le déploiement et l’utilisation à 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 classe SerializerWriter, sont compilés et liés directement dans l’application. Les sérialiseurs de plug-in et les sérialiseurs liés fonctionnent à l’aide de méthodes publiques et d’événements identiques, ce qui facilite l’utilisation des deux types de sérialiseurs dans la même application.

Les sérialiseurs de plug-in aident les développeurs d’applications en fournissant une extensibilité aux nouvelles conceptions de stockage et aux formats de fichiers sans avoir à coder directement pour chaque format potentiel au moment de la génération. Les sérialiseurs de plug-in bénéficient également aux développeurs tiers en fournissant un moyen standardisé de déployer, d’installer et de mettre à jour des plug-ins accessibles au système 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. Le 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 méthode CreateSerializerWriter est utilisée pour créer un SerializerWriter pour le format spécifique. La méthode SerializerWriter.Write 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 méthode SerializerProvider 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 méthode CreateSerializerWriter 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 classe SerializerProvider 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 spécificités des sérialiseurs installés sont définies par le biais des paramètres de Registre. Les sérialiseurs de plug-in peuvent être ajoutés au Registre à l’aide de la méthode RegisterSerializer ; 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 méthode UnregisterSerializer 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 plugin

Les sérialiseurs de plug-in et les sérialiseurs liés utilisent les mêmes méthodes et événements publics exposés, et de la même façon peuvent être conçus pour fonctionner de manière synchrone ou asynchrone. Il existe trois étapes de base normalement suivies pour créer un sérialiseur de plug-in :

Implémentez et déboguez d’abord le sérialiseur en tant que sérialiseur associé. 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 interface ISerializerFactory est ajoutée pour créer un plug-in. L’interface ISerializerFactory autorise l’accès complet à tous les objets .NET Framework qui incluent l’arborescence logique, les objets UIElement, les IDocumentPaginatorSourceet les éléments Visual. En outre, ISerializerFactory fournit les mêmes méthodes et événements synchrones et asynchrones que ceux utilisés par les sérialiseurs liés. Étant donné que les documents volumineux peuvent prendre du temps à générer, les opérations asynchrones sont recommandées pour maintenir une interaction utilisateur réactive et offrir une option « Annuler » si un problème se produit avec le magasin de données.
Une fois le sérialiseur plug-in créé, un script d’installation est implémenté pour distribuer et installer (et désinstaller) le plug-in (voir ci-dessus, «Installation de sérialiseurs de plug-ins»).

Partager via