Serialisierung und Speicherung von Dokumenten

2025-05-07

Microsoft .NET Framework bietet eine leistungsstarke Umgebung zum Erstellen und Anzeigen von qualitativ hochwertigen Dokumenten. Erweiterte Funktionen, die sowohl Fixed-Documents als auch Flussdokumente unterstützen, sowie fortschrittliche Anzeigesteuerelemente in Kombination mit leistungsstarken 2D- und 3D-Grafikfähigkeiten heben .NET Framework-Anwendungen auf eine neue Stufe von Qualität und Benutzererfahrung. Die flexible Verwaltung einer In-Memory-Darstellung eines Dokuments ist ein wichtiges Feature des .NET Framework, und das effiziente Speichern und Laden von Dokumenten aus einem Datenspeicher ist ein Bedarf fast aller Anwendungen. Der Prozess der Konvertierung eines Dokuments aus einer internen Speicherdarstellung in einen externen Datenspeicher wird als Serialisierung bezeichnet. Der umgekehrte Prozess zum Lesen eines Datenspeichers und zum Erneuten Erstellen der ursprünglichen Speicherinstanz wird als Deserialisierung bezeichnet.

Informationen zur Serialisierung von Dokumenten

Im Idealfall ist der Prozess der Serialisierung und Deserialisierung eines Dokuments in den Arbeitsspeicher und wieder zurück für die Anwendung transparent. Die Anwendung ruft eine Serialisierer "write"-Methode auf, um das Dokument zu speichern, während eine Deserialisierer "read"-Methode 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 Optionen wie "Speichern unter" anbieten, um ein Dokument in einer Datenträgerdatei, einer Datenbank oder einem 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-APIs System.Windows.Documents.Serialization mehrere weitere wichtige Features.

Features von .NET Framework 3.0 Document Serializers

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 Anwendungs-Plug-In-Auffindbarkeit.
- 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 Schreiben 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 Ausgabeoptionen und -funktionen für druckpfade finden Sie in der Druckübersicht .

Plug-in-Serializer

Die System.Windows.Documents.Serialization APIs unterstützen sowohl Plug-In-Serialisierer als auch verknüpfte Serialisierer, die separat von der Anwendung installiert werden, zur Laufzeit gebunden sind und über den SerializerProvider-Ermittlungsmechanismus darauf zugegriffen wird. Plug-In-Serialisierer bieten erweiterte Vorteile für die einfache Bereitstellung und systemweite 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, die die Verwendung dieser oder beider Typen von Serialisierern in derselben Anwendung erleichtern.

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 Drittanbieterentwicklern Vorteile, indem sie standardisierte Mittel zum Bereitstellen, Installieren und Aktualisieren von systemzugänglichen Plug-Ins für benutzerdefinierte oder proprietäre Dateiformate bereitstellen.

Verwenden eines Plug-In-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. Andere Eigenschaften wie SerializerDescriptor, DisplayName und DefaultFileExtension werden ebenfalls bereitgestellt, die die Anwendung nutzen kann, um den Benutzer beim Auswählen eines Serialisierers für ein verfügbares Ausgabeformat aufzufordern. Ein Standardmäßiger Plug-In-Serializer für XPS wird mit .NET Framework bereitgestellt und wird immer aufgezählt. Nachdem der Benutzer ein Ausgabeformat ausgewählt hat, wird die CreateSerializerWriter Methode verwendet, um ein SerializerWriter für das spezifische Format zu erstellen. Die SerializerWriter.Write Methode kann dann aufgerufen werden, um den Dokumentdatenstrom in den Datenspeicher auszugeben.

Das folgende Beispiel veranschaulicht eine Anwendung, 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 ein 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-Serializern

Die SerializerProvider Klasse bietet die Anwendungsschnittstelle auf höherer Ebene für die Entdeckung und den Zugriff von Plug-in-Serialisierern. SerializerProvider sucht und stellt die Anwendung eine Liste der Serialisierer bereit, die auf dem System installiert und zugänglich sind. Die Besonderheiten der installierten Serialisierer werden über Registrierungseinstellungen definiert. Plug-In-Serialisierer können mithilfe der RegisterSerializer Methode zur Registrierung hinzugefügt werden. 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.

Erstellung eines Plug-in-Serializers

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 und Verknüpfen des kompilierten Serialisierers direkt in einer Testanwendung bietet Vollzugriff auf Haltepunkte und andere für Tests hilfreiche Debug-Dienste.
Nachdem der Serialisierer vollständig getestet wurde, wird eine ISerializerFactory Schnittstelle zum Erstellen eines Plug-Ins hinzugefügt. Die ISerializerFactory Schnittstelle ermöglicht den vollständigen Zugriff auf alle .NET Framework-Objekte, die die logische Struktur, UIElement IDocumentPaginatorSourceObjekte und Visual Elemente enthalten. ISerializerFactory Darüber hinaus werden dieselben synchronen und asynchronen Methoden und Ereignisse bereitgestellt, die von verknüpften Serialisierern verwendet werden. Da es bei großen Dokumenten eine Weile dauern kann, bis sie ausgegeben werden, empfiehlt es sich, asynchrone Vorgänge zu verwenden, um reaktionsschnelle Benutzerinteraktionen aufrechtzuerhalten und eine "Abbrechen"-Option anzubieten, wenn ein Problem mit dem Datenspeicher auftritt.
Nachdem das Plug-In serializer erstellt wurde, wird ein Installationsskript für die Verteilung und Installation (und Deinstallation) des Plug-Ins implementiert (siehe oben, "Installieren von Plug-In-Serializern").

Freigeben über