Serialisierung und Speicherung von Dokumenten

Artikel
12/19/2024

Microsoft .NET Framework bietet eine leistungsstarke Umgebung zum Erstellen und Anzeigen von qualitativ hochwertigen Dokumenten. Erweiterte Features, die sowohl Fixed-Dokumente als auch Flussdokumente unterstützen, und erweiterte Anzeigesteuerelemente kombiniert mit leistungsstarken 2D- und 3D-Grafikfunktionen heben .NET-Framework-Anwendungen auf ein neues Niveau von Qualität und Benutzererfahrung. Die flexible Verwaltung einer speicherinternen Darstellung eines Dokuments ist eine zentrale Funktion des .NET Framework, und das effiziente Speichern und Laden von Dokumenten aus einem Datenspeicher ist eine Anforderung für fast jede Anwendung. Der Prozess der Konvertierung eines Dokuments aus einer internen Speicherdarstellung in einen externen Datenspeicher wird als Serialisierung bezeichnet. Der umgekehrte Prozess, bei dem ein Datenspeicher gelesen und die ursprüngliche Instanz im Speicher wiederhergestellt wird, wird als Deserialisierung bezeichnet.

Informationen zur Serialisierung von Dokumenten

Im Idealfall ist der Serialisierungs- und Deserialisierungsprozess eines Dokuments in und aus dem Arbeitsspeicher für die Anwendung transparent. Die Anwendung ruft eine Serializer-Methode "schreiben" auf, um das Dokument zu speichern, während eine Deserializer-Methode "lesen" auf den Datenspeicher zugreift und die ursprüngliche Instanz im Arbeitsspeicher neu erstellt. Das spezifische Format, in dem die Daten gespeichert werden, ist in der Regel kein Problem der Anwendung, solange der Serialisierungs- und Deserialisierungsprozess das Dokument wieder in seine ursprüngliche Form zurück erstellt.

Anwendungen bieten häufig mehrere Serialisierungsoptionen, mit denen der Benutzer Dokumente auf einem anderen Medium oder in einem anderen Format speichern kann. Eine Anwendung kann beispielsweise Speicheroptionen wie "Speichern unter" anbieten, um ein Dokument in einer Datenträgerdatei, Datenbank oder einen Webdienst zu speichern. Ebenso könnten unterschiedliche Serialisierer das Dokument in verschiedenen Formaten speichern, z. B. in HTML, RTF, XML, XPS oder alternativ zu einem Drittanbieterformat. Für die Anwendung definiert die Serialisierung eine Schnittstelle, die die Details des Speichermediums innerhalb der Implementierung jedes bestimmten Serialisierers isoliert. Zusätzlich zu den Vorteilen der Kapselung von Speicherdetails bieten die .NET Framework System.Windows.Documents.Serialization-APIs mehrere weitere wichtige Features.

Funktionen von .NET Framework 3.0 Dokument-Serialisierern

Direkter Zugriff auf die übergeordneten Dokumentobjekte (logische Struktur und visuelle Elemente) ermöglichen eine effiziente Speicherung von paginierten Inhalten, 2D/3D-Elementen, Bildern, Medien, Links, Anmerkungen und anderen Unterstützungsinhalten.
Synchroner und asynchroner Vorgang.
Unterstützung für Plug-In-Serialisierer mit erweiterten Funktionen:
- Systemweiter Zugriff für die Verwendung durch alle .NET Framework-Anwendungen.
- Einfache Entdeckbarkeit von Anwendungs-Plugins.
- Einfache Bereitstellung, Installation und Aktualisierung für benutzerdefinierte Plug-Ins von Drittanbietern.
- Benutzeroberflächenunterstützung für benutzerdefinierte Laufzeiteinstellungen und -optionen.

XPS-Druckpfad

Der Microsoft .NET Framework XPS-Druckpfad bietet außerdem einen erweiterbaren Mechanismus zum Verfassen von Dokumenten über die Druckausgabe. XPS dient sowohl als Dokumentdateiformat als auch als systemeigenes Druckspoolformat für Windows Vista. XPS-Dokumente können direkt an XPS-kompatible Drucker gesendet werden, ohne dass eine Konvertierung in ein Zwischenformat erforderlich ist. Weitere Informationen zu Druckpfaadausgabeoptionen und -funktionen finden Sie in der Druckübersicht.

Plug-in-Serializer

Die System.Windows.Documents.Serialization-APIs bieten Unterstützung für Plug-In-Serialisierer und verknüpfte Serialisierer, die separat von der Anwendung installiert werden, zur Laufzeit gebunden werden und über den SerializerProvider-Ermittlungsmechanismus darauf zugegriffen wird. Plug-In-Serializer bieten erweiterte Vorteile zur Erleichterung der Bereitstellung und systemweiten Verwendung. Verknüpfte Serialisierer können auch für teilweise vertrauenswürdige Umgebungen wie XAML-Browseranwendungen (XBAPs) implementiert werden, auf die Plug-In-Serialisierer nicht zugreifen können. Verknüpfte Serialisierer, die auf einer abgeleiteten Implementierung der SerializerWriter Klasse basieren, werden kompiliert und direkt mit der Anwendung verknüpft. Sowohl Plug-In-Serialisierer als auch verknüpfte Serialisierer funktionieren über identische öffentliche Methoden und Ereignisse, was die Verwendung beider Arten von Serialisierern in derselben Anwendung erleichtert.

Plug-In-Serialisierer unterstützen Anwendungsentwickler, indem sie die Erweiterbarkeit für neue Speicherdesigns und Dateiformate bereitstellen, ohne für jedes potenzielle Format zur Erstellungszeit direkt codieren zu müssen. Plug-In-Serialisierer bieten auch Drittanbieterentwicklern den Vorteil, eine standardisierte Methode zum Bereitstellen, Installieren und Aktualisieren von systemzugänglichen Plug-Ins für benutzerdefinierte oder proprietäre Dateiformate zu verwenden.

Verwenden eines Plugin-Serializers

Plug-In-Serialisierer sind einfach zu verwenden. Die SerializerProvider Klasse listet ein SerializerDescriptor-Objekt für jedes Plug-In auf, das auf dem System installiert ist. Die IsLoadable-Eigenschaft filtert die installierten Plug-Ins basierend auf der aktuellen Konfiguration und überprüft, ob der Serialisierer von der Anwendung geladen und verwendet werden kann. Die SerializerDescriptor stellt auch andere Eigenschaften bereit, z. B. DisplayName und DefaultFileExtension, die die Anwendung verwenden kann, um den Benutzer zur Auswahl eines Serialisierers für ein verfügbares Ausgabeformat aufzufordern. Ein standardmäßiger Plugin-Serializer für XPS wird mit dem .NET Framework bereitgestellt und immer aufgelistet. Nachdem der Benutzer ein Ausgabeformat ausgewählt hat, wird die CreateSerializerWriter-Methode verwendet, um eine SerializerWriter für das spezifische Format zu erstellen. Die SerializerWriter.Write-Methode kann dann aufgerufen werden, um den Dokumentdatenstrom in den Datenspeicher auszugeben.

Im folgenden Beispiel wird eine Anwendung veranschaulicht, die die SerializerProvider-Methode in einer "PlugInFileFilter"-Eigenschaft verwendet. PlugInFileFilter listet die installierten Plug-Ins auf und erstellt eine Filterzeichenfolge mit den verfügbaren Dateioptionen für eine 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;
    }
}

Nachdem ein Ausgabedateiname vom Benutzer ausgewählt wurde, veranschaulicht das folgende Beispiel die Verwendung der CreateSerializerWriter-Methode zum Speichern eines bestimmten Dokuments in einem angegebenen Format.

// 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;
}

Installieren von Plugin-Serialisierern

Die SerializerProvider Klasse stellt die Benutzeroberfläche der oberen Ebene für die Erkennung und den Zugriff auf Plug-In-Serialisierer zur Anwendung. SerializerProvider sucht und stellt der Anwendung eine Liste der Serialisierer zur Verfügung, die auf dem System installiert und zugänglich sind. Die Besonderheiten der installierten Serialisierer werden über Registrierungseinstellungen definiert. Plug-In-Serialisierer können der Registrierung mithilfe der RegisterSerializer-Methode hinzugefügt werden; oder wenn .NET Framework noch nicht installiert ist, kann das Plug-In-Installationsskript die Registrierungswerte selbst direkt festlegen. Die UnregisterSerializer-Methode kann verwendet werden, um ein zuvor installiertes Plug-In zu entfernen, oder die Registrierungseinstellungen können durch ein Deinstallationsskript auf ähnliche Weise zurückgesetzt werden.

Erstellen eines Plugin-Serialisierers

Sowohl Plug-In-Serialisierer als auch verknüpfte Serialisierer verwenden dieselben verfügbar gemachten öffentlichen Methoden und Ereignisse und können auf ähnliche Weise so konzipiert werden, dass sie synchron oder asynchron ausgeführt werden. Es gibt drei grundlegende Schritte, die normalerweise zum Erstellen eines Plug-In-Serialisierungsprogramms befolgt werden:

Implementieren und debuggen Sie den Serialisierer zuerst als verknüpfter Serialisierer. Das anfängliche Erstellen des Serialisierers, der kompiliert und direkt in einer Testanwendung verknüpft wird, bietet Vollzugriff auf Haltepunkte und andere Debugdienste, die für Tests hilfreich sind.
Nachdem der Serialisierer vollständig getestet wurde, wird eine ISerializerFactory-Schnittstelle hinzugefügt, um ein Plug-in zu erstellen. Die ISerializerFactory-Schnittstelle ermöglicht den vollständigen Zugriff auf alle .NET Framework-Objekte, die aus der logischen Struktur, UIElement Objekten, IDocumentPaginatorSourceund Visual Elementen bestehen. Darüber hinaus stellt ISerializerFactory die gleichen synchronen und asynchronen Methoden und Ereignisse bereit, die von verknüpften Serialisierern verwendet werden. Da große Dokumente Zeit benötigen können, wird empfohlen, asynchrone Vorgänge zu verwenden, um reaktionsfähige Benutzerinteraktionen aufrechtzuerhalten und eine Option zum Abbrechen anzubieten, falls ein Problem mit dem Datenspeicher auftritt.
Nachdem der Plug-in-Serialisierer erstellt wurde, wird ein Installationsskript für die Verteilung, Installation und Deinstallation des Plug-ins implementiert (siehe oben: "Installieren von Plug-in-Serialisierern").

Freigeben über