Partager via

Sérialisation et stockage des documents

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 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 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 des sérialiseurs plug-in avec des fonctionnalités améliorées :

    • Accès à l’échelle du système pour une utilisation par toutes les applications .NET Framework.

    • Détectabilité des plug-ins pour une application simple.

    • Déploiement, installation et mise à jour simples pour les plug-ins tiers personnalisés.

    • Prise en charge de l’interface utilisateur pour les paramètres et options d’exécution personnalisés.

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 vue d’ensemble de l’impression pour plus d’informations sur les options et fonctionnalités de sortie du chemin d’impression.

Sérialiseurs de plug-in

Les System.Windows.Documents.Serialization API prennent en charge les sérialiseurs plug-in et les sérialiseurs liés, qui sont installés séparément de l’application, se lient au moment de l'exécution et sont accessibles par 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 SerializerWriter classe, 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 serializeur de plugin

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 des 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 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 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-in

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 :

  1. Implémentez et déboguez d’abord le sérialiseur en tant que sérialiseur lié. Au départ, créer le sérialiseur compilé et lié directement dans une application de test permet d'avoir un accès complet aux points d'arrêt et à d'autres services de débogage utiles pour le test.

  2. 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. ISerializerFactory fournit également 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.

  3. 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 des sérialiseurs de plug-in »).

Voir aussi