Serialisierung und Speicherung von Dokumenten
Microsoft .NET Framework stellt eine leistungsstarke Umgebung für das Erstellen und Anzeigen qualitativ hochwertiger Dokumente bereit. Erweiterte Features, die einheitlich dargestellte Dokumente und Flussdokumente unterstützen, und erweiterte Anzeigesteuerelemente in Kombination mit leistungsstarken 2D- und 3D-Grafikfunktionen heben .NET Framework-Anwendungen in Bezug auf Qualität und Benutzerfreundlichkeit auf ein neues Niveau. Die Möglichkeit der flexiblen Verwaltung einer speicherinternen Darstellung eines Dokument ist ein zentrales Feature von .NET Framework, während das effiziente Speichern und Laden von Dokumenten aus einem Datenspeicher eine Anforderung bei fast allen Anwendungen ist. Der Prozess der Konvertierung eines Dokuments aus einer speicherinternen Darstellung in einen externen Datenspeicher wird als Serialisierung bezeichnet. Der umgekehrte Prozess, einen Datenspeicher zu lesen und die ursprüngliche speicherinterne Instanz neu zu erstellen, wird als Deserialisierung bezeichnet.
Dieses Thema enthält folgende Abschnitte.
- Informationen zur Dokumentserialisierung
- Plug-In-Serialisierungsprogramme
- Verwandte Abschnitte
Informationen zur Dokumentserialisierung
Im Idealfall ist der Prozess der Serialisierung und Deserialisierung eines Dokuments aus dem Speicher und anschließend zurück in den Speicher für die Anwendung transparent. Die Anwendung ruft eine Write-Methode des Serialisierungsprogramms auf, um das Dokument zu speichern, während eine Read-Methode des Deserialisierungsprogramms auf den Datenspeicher zugreift und die ursprüngliche Instanz im Speicher neu erstellt. Das spezifische Format, in dem die Daten gespeichert werden, spielt für die Anwendung in der Regel keine Rolle, solange das Dokument im Rahmen des Serialisierungs- und Deserialisierungsprozesses neu in seiner ursprünglichen Form erstellt wird.
Häufig bieten Anwendungen mehrere Serialisierungsoptionen, sodass der Benutzer Dokumente auf einem anderen Medium oder in einem anderen Format speichern kann. Eine Anwendung kann z. B. "Speichern unter"-Optionen anbieten, um ein Dokument in einer Datenträgerdatei, einer Datenbank oder einem Webdienst zu speichern. Ebenso können verschiedene Serialisierungsprogramme das Dokument in verschiedenen Formaten wie HTML, RTF, XML, XPS oder alternativ im Format eines Drittanbieters speichern. Für die Anwendung wird durch die Serialisierung eine Schnittstelle definiert, die die Details des Speichermediums innerhalb der Implementierung jedes einzelnen Serialisierungsprogramms isoliert. Neben den Vorteilen der Kapselung von Speicherdetails bieten die .NET Framework-System.Windows.Documents.Serialization-APIs noch weitere wichtige Features.
Features der Dokumentserialisierungsprogramme von .NET Framework 3.0
Der Direktzugriff auf die Dokumentobjekte der höheren Ebene (logische Struktur und visuelle Elemente) ermöglicht die 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-Serialisierungsprogramme mit erweiterten Funktionen:
Systemweiter Zugriff für alle .NET Framework-Anwendungen.
Einfache Auffindbarkeit von Anwendungs-Plug-Ins.
Einfaches Bereitstellen, Installieren und Aktualisieren für benutzerdefinierte Drittanbieter-Plug-Ins.
Benutzeroberflächenunterstützung für benutzerdefinierte Laufzeiteinstellungen und Optionen.
XPS-Druckpfad
Der Microsoft .NET Framework XPS bietet auch einen erweiterbaren Mechanismus für das Schreiben von Dokumenten durch die Druckausgabe. Dabei dient XPS sowohl als Dokumentdateiformat als auch als systemeigenes Druckerspoolformat für Windows Vista. XPS-Dokumente können ohne vorherige Konvertierung in ein Zwischenformat direkt an XPS-kompatible Drucker gesendet werden. Weitere Informationen über Optionen und Funktionen für die Druckpfadausgabe finden Sie unter Übersicht über das Drucken.
Plug-In-Serialisierungsprogramme
Die System.Windows.Documents.Serialization-APIs bieten Unterstützung sowohl für Plug-In-Serialisierungsprogramme als auch für verknüpfte Serialisierungsprogramme, die separat von der Anwendung installiert, zur Laufzeit gebunden und vom SerializerProvider-Discovery-Mechanismus aufgerufen werden. Plug-In-Serialisierungsprogramme bieten mehr Vorteile im Bezug auf Bereitstellung und systemweite Verwendung. Verknüpfte Serialisierungsprogramme können auch für teilweise vertrauenswürdige Umgebungen wie XAML browser applications (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 dieselben öffentlichen Methoden und Ereignisse. Dadurch können beide problemlos in einer Anwendung verwendet werden.
Plug-In-Serialisierungsprogramme bieten Entwicklern die Möglichkeit, Anwendungen um neue Speicherentwürfe und Dateiformate zu erweitern, ohne jedes potenzielle Format bereits zur Erstellungszeit codieren zu müssen. Darüber hinaus profitieren auch Drittanbieterentwickler von Plug-In-Serialisierungsprogrammen, weil sie damit eine standardisierte Methode zum Bereitstellen, Installieren und Aktualisieren der für das System zugänglichen Plug-Ins für benutzerdefinierte oder proprietäre Dateiformate erhalten.
Verwenden eines Plug-In-Serialisierungsprogramms
Plug-In-Serialisierungsprogramme sind einfach zu verwenden. Die SerializerProvider-Klasse listet ein SerializerDescriptor-Objekt für jedes auf dem System installierte Plug-In auf. Die IsLoadable-Eigenschaft filtert die installierten Plug-Ins auf Basis der aktuellen Konfiguration und prüft, ob das Serialisierungsprogramm von der Anwendung geladen und verwendet werden kann. SerializerDescriptor stellt noch weitere Eigenschaften wie DisplayName und DefaultFileExtension bereit, mit denen die Anwendung den Benutzer aufordern kann, ein Serialisierungsprogramm für ein verfügbares Ausgabeformat auszuwählen. .NET Framework beinhaltet ein Standard-Plug-In-Serialisierungsprogramm für XPS, das immer aufgelistet wird. Nachdem der Benutzer ein Ausgabeformat ausgewählt hat, wird mit der CreateSerializerWriter-Methode ein SerializerWriter für das bestimmte Format erstellt. Anschließend kann die SerializerWriter.Write-Methode aufgerufen werden, um den Dokumentstream 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 ein SaveFileDialog-Element.
// ------------------------ 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;
}
}
Im folgende Beispiel wird die Verwendung der CreateSerializerWriter-Methode veranschaulicht, um ein bestimmtes Dokument in einem angegebenen Format zu speichern, nachdem der Benutzer einen Namen für die Ausgabedatei ausgewählt hat.
// 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 SerializerProvider-Klasse liefert die Anwendungsschnittstelle der höheren Ebene für das Auffinden und den Zugriff des Plug-In-Serialisierungsprogramms. SerializerProvider sucht und stellt der Anwendung eine Liste der Serialisierungsprogramme bereit, die auf dem System installiert sind, und auf die Sie zugreifen können. Die Einzelheiten der installierten Serialisierungsprogramme werden durch Registrierungseinstellungen definiert. Plug-In-Serialisierungsprogramme können der Registrierung mithilfe der RegisterSerializer-Methode hinzugefügt werden. Wenn .NET Framework nicht installiert ist, kann das Plug-In-Installationsskript die Registrierungswerte auch direkt selbst festlegen. Zuvor installierte Plug-Ins können mithilfe der UnregisterSerializer-Methode entfernt werden, oder ein Deinstallationsskript setzt die Registrierungseinstellungen wieder zurück.
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 auch für den synchronen oder asynchronen Vorgang konfiguriert werden. Es gibt in der Regel drei grundlegende Schritte, um ein Plug-In-Serialisierungsprogramm zu erstellen:
Implementieren und debuggen Sie das Serialisierungsprogramm zuerst als verknüpftes Serialisierungsprogramm. Durch anfängliche Erstellung des Serialisierungsprogramms als kompilierte und direkt mit einer Testanwendung verknüpfte Version, erhalten Sie vollständigen Zugriff auf Haltepunkte und andere Debugdienste, die für das Testen hilfreich sind.
Nach dem vollständigen Testen des Serialisierungsprogramms wird eine ISerializerFactory-Schnittstelle hinzugefügt, um ein Plug-In zu erstellen. Die ISerializerFactory-Schnittstelle erlaubt den vollständigen Zugriff auf alle .NET Framework-Objekte einschließlich der lokalen Struktur, UIElement-Objekte, IDocumentPaginatorSource-Elemente und Visual-Elemente. Darüber hinaus stellt ISerializerFactory dieselben synchronen und asynchronen Methoden und Ereignisse wie für verknüpfte Serialisierungsprogramme bereit. Da die Ausgabe großer Dokumente länger dauern kann, werden asynchrone Vorgänge empfohlen, um weiterhin auf Benutzerinteraktionen reagieren und eine Option "Abbrechen" anbieten zu können, wenn ein Problem mit dem Datenspeicher auftritt.
Nach der Erstellung des Plug-In-Serialisierungsprogramms wird ein Installationsskript für die Verteilung und Installation (sowie die Deinstallation) des Plug-Ins implementiert (weitere Informationen finden Sie weiter oben unter Installieren von Plug-In-Serialisierungsprogrammen).
Siehe auch
Referenz
System.Windows.Documents.Serialization