Serialisierung und Speicherung von Dokumenten

  • Artikel

Microsoft .NET Framework bietet eine leistungsfähige Umgebung zum Erstellen und Anzeigen qualitativ hochwertiger Dokumente. Erweiterte Funktionen zur Unterstützung von sowohl fixierten als auch Flussdokumenten sowie erweiterte Anzeigesteuerelemente in Kombination mit leistungsstarken 2D- und 3D-Grafikfunktionen führen .NET Framework-Anwendungen auf ein neues Level in Bezug auf Qualität und Benutzerfreundlichkeit. Eine der wichtigsten Funktionen von .NET Framework ist die flexible Verwaltung der speicherinternen Darstellung eines Dokuments. Die Möglichkeit, Dokumente effizient zu speichern und aus einem Datenspeicher zu laden, ist eine Anforderung, die an nahezu jede Anwendung gestellt wird. Der Prozess der Konvertierung eines Dokuments aus einer speicherinternen Darstellung in einen externen Datenspeicher wird als Serialisierung bezeichnet. Der umgekehrte Vorgang des Lesens eines Datenspeichers und Neuerstellens der ursprünglichen Instanz im Speicher wird Deserialisierung genannt.

Informationen zur Dokumentserialisierung

Im Idealfall ist der Prozess der Serialisierung und Deserialisierung eines Dokuments aus dem Speicher und wieder zurück für die Anwendung transparent. Die Anwendung ruft die Write-Methode des Serialisierungsprogramms auf, um das Dokument zu speichern. Die Read-Methode des Deserialisierungsprogramms greift dagegen auf den Datenspeicher zu und erstellt die ursprüngliche Instanz im Speicher neu. Das jeweilige Format, in dem die Daten gespeichert werden, ist für die Anwendung normalerweise nicht relevant, solange der Serialisierungs- und Deserialisierungsprozess das Dokument wieder in seiner ursprünglichen Form erstellt.

Oft bieten Anwendungen mehrere Serialisierungsoptionen, die dem Benutzer die Speicherung von Dokumenten auf ein anderes Medium oder in ein anderes Format ermöglichen. So kann eine Anwendung z.B. „Speichern unter“-Optionen anbieten, um ein Dokument in eine Datenträgerdatei, Datenbank oder einen Webdienst zu speichern. Entsprechend können verschiedene Serialisierungsprogramme das Dokument in verschiedenen Formaten speichern, wie etwa HTML, RTF, XML, XPS oder das Format eines Drittanbieters. Für die Anwendung wird eine Schnittstelle definiert, die die Details des Speichermediums innerhalb der Implementierung jedes einzelnen Serialisierungsprogramms isoliert. Zusätzlich zu den Vorteilen der Kapselung von Speicherdetails bietet die System.Windows.Documents.Serialization-API von .NET Framework einige weitere wichtige Funktionen.

Funktionen der Dokumentserialisierungsprogramme von .NET Framework 3.0

  • Durch direkten Zugriff auf Dokumentobjekte der höheren Ebene (logische Struktur und visuelle Elemente) wird eine effiziente Speicherung von aufgeteiltem Inhalt, 2D-/3D-Elementen, Bildern, Medien, Hyperlinks, Anmerkungen und anderen Supportinhalten aktiviert.

  • Synchrone und asynchrone Vorgänge

  • Unterstützung für Plug-In-Serialisierungsprogramme mit erweiterten Funktionen:

    • Systemweiter Zugriff für die Verwendung durch alle .NET Framework-Anwendungen

    • Einfache Erkennbarkeit von Anwendungs-Plug-Ins

    • Einfache Bereitstellung, Installation und Update von benutzerdefinierten Drittanbieter-Plug-Ins

    • Unterstützung von Benutzeroberflächen für benutzerdefinierte Laufzeiteinstellungen und -optionen

XPS-Druckpfad

Der Microsoft .NET Framework XPS-Druckpfad bietet auch einen erweiterbaren Mechanismus zum Schreiben von Dokumenten durch die Druckausgabe. XPS dient gleichzeitig als Dokumentdateiformat und natives Druckerspoolerformat für Windows Vista. XPS-Dokumente können ohne Konvertierung in ein Zwischenformat direkt an XPS-kompatible Drucker geschickt werden. Weitere Informationen zu Optionen und Funktionen der Druckpfadausgabe finden Sie unter Übersicht über das Drucken.

Plug-In-Serialisierungsprogramme

Die System.Windows.Documents.Serialization-APIs bieten Unterstützung für Plug-In-Serialisierungsprogramme und verknüpfte Serialisierungsprogramme, die getrennt von der Anwendung installiert und zur Laufzeit gebunden werden und auf die mithilfe des SerializerProvider-Ermittlungsmechanismus zugegriffen wird. Plug-In-Serialisierungsprogramme bieten mehr Vorteile hinsichtlich einfacher Bereitstellung und systemweiter Verwendung. Verknüpfte Serialisierungsprogramme können auch für teilweise vertrauenswürdige Umgebungen wie z. B. XAML Browseranwendungen (XBAPs) implementiert werden, in denen nicht auf Plug-In-Serialisierungsprogramme zugegriffen werden kann. Verknüpfte Serialisierungsprogramme, die auf einer abgeleiteten Implementierung der SerializerWriter-Klasse basieren, werden kompiliert und direkt mit der Anwendung verknüpft. Plug-In-Serialisierungsprogramme und verknüpfte Serialisierungsprogramme verwenden identische öffentliche Methoden und Ereignisse. Daher können eine oder beide Arten von Serialisierungsprogrammen problemlos in der gleichen Anwendung verwendet werden.

Plug-In-Serialisierungsprogramme helfen Anwendungsentwicklern durch die Möglichkeit zur Erweiterung bei neuen Speicherentwürfen und Dateiformaten, ohne dass sie bereits bei der Erstellung für jedes mögliche Format programmieren müssen. Von Plug-In-Serialisierungsprogrammen profitieren auch Drittanbieterentwickler durch eine standardisierte Methode, barrierefrei Plug-Ins für benutzerdefinierte oder geschützte Dateiformate bereitzustellen, zu installieren und zu aktualisieren.

Verwenden eines Plug-In-Serialisierungsprogramms

Plug-In-Serialisierungsprogramme sind einfach zu verwenden. Die Klasse SerializerProvider listet für jedes auf dem System installierte Plug-in ein SerializerDescriptor-Objekt auf. Die IsLoadable-Eigenschaft filtert die installierten Plug-Ins auf Grundlage der aktuellen Konfiguration und überprüft, ob das Serialisierungsprogramm von der Anwendung geladen und verwendet werden kann. Der SerializerDescriptor bietet auch andere Eigenschaften, wie z. B. DisplayName und DefaultFileExtension, die die Anwendung verwenden kann, um den Benutzer bei der Auswahl eines Serialisierungsprogramms für ein verfügbares Ausgabeformat zu unterstützen. Ein Standard-Plug-In-Serialisierungsprogramm für XPS ist in .NET Framework enthalten und wird immer aufgelistet. Nachdem der Benutzer ein Ausgabeformat ausgewählt hat, wird die CreateSerializerWriter-Methode verwendet, um einen SerializerWriter für das spezifische Format zu erstellen. Die SerializerWriter.Write-Methode kann dann aufgerufen werden, um den Dokumentenstrom an 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 einen 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 der Benutzer einen Namen für die Ausgabedatei ausgewählt hat, zeigt das folgende Beispiel die Verwendung der CreateSerializerWriter-Methode zum Speichern eines bestimmten Dokuments in einem bestimmten 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 Plug-In-Serialisierungsprogrammen

Die Klasse SerializerProvider stellt die obere Anwendungsschnittstelle für die Ermittlung von und den Zugriff auf Plug-in-Serialisierungsprogramme bereit. SerializerProvider sucht und stellt der Anwendung eine Liste der Serialisierungsprogramme zur Verfügung, die installiert und im System zugänglich sind. Die Einzelheiten der installierten Serialisierungsprogramme werden durch Registrierungseinstellungen definiert. Plug-In-Serialisierungsprogramme können der Registrierung mit der RegisterSerializer-Methode hinzugefügt werden. Ist .NET Framework noch nicht installiert, kann auch das Plug-In-Installationsskript selbst die Registrierungswerte festlegen. Die UnregisterSerializer-Methode kann verwendet werden, um ein zuvor installiertes Plug-in zu entfernen, oder die Registrierungseinstellungen können auf ähnliche Weise durch ein Deinstallationsskript zurückgesetzt werden.

Erstellen eines Plug-In-Serialisierungsprogramms

Plug-In-Serialisierungsprogramme und verknüpfte Serialisierungsprogramme verwenden dieselben verfügbar gemachten, öffentlichen Methoden und Ereignisse und können daher so entworfen werden, dass sie synchron oder asynchron ausgeführt werden. Folgen Sie diesen drei grundlegenden Schritten zum Erstellen eines Plug-In-Serialisierungsprogramms:

  1. Implementieren und debuggen Sie das Serialisierungsprogramm zuerst als verknüpftes Serialisierungsprogramm. Das vorherige Erstellen des Serialisierungsprogramms, das kompiliert und direkt mit der Testanwendung verknüpft wird, ermöglicht vollen Zugriff auf Haltepunkte und weitere für den Test nützliche Debugdienste.

  2. Nachdem das Serialisierungsprogramm vollständig getestet wurde, wird eine ISerializerFactory-Schnittstelle hinzugefügt, um ein Plug-In zu erstellen. Die ISerializerFactory-Schnittstelle ermöglicht vollständigen Zugriff auf alle .NET Framework-Objekte, was die logische Struktur, UIElement-Objekte IDocumentPaginatorSource- und Visual-Elemente beinhaltet. Darüber hinaus bietet ISerializerFactory dieselben synchronen und asynchronen Methoden und Ereignisse wie für verknüpfte Serialisierungsprogramme. Da die Ausgabe großer Dokumente mehr Zeit in Anspruch nehmen kann, sind asynchrone Vorgänge empfehlenswert, um eine reaktionsfähige Benutzerinteraktion und eine Abbrechen-Option zu gewährleisten, falls ein Problem mit dem Datenspeicher auftreten sollte.

  3. Nach Erstellen des Plug-In-Serialisierungsprogramms wird ein Installationsskript für die Verteilung und Installation (und Deinstallation) des Plug-Ins implementiert (siehe oben unter „Installieren von Plug-In-Serialisierungsprogrammen“).

Weitere Informationen