Serialisatie en opslag van documenten

Microsoft .NET Framework biedt een krachtige omgeving voor het maken en weergeven van documenten van hoge kwaliteit. Verbeterde functies die ondersteuning bieden voor zowel vaste documenten als stroomdocumenten, geavanceerde besturingselementen voor weergave, gecombineerd met krachtige 2D- en 3D-grafische mogelijkheden, brengen .NET Framework-toepassingen naar een nieuw niveau van kwaliteit en gebruikerservaring. Het flexibel beheren van een in-memory weergave van een document is een belangrijke functie van .NET Framework en het efficiënt opslaan en laden van documenten uit een gegevensarchief is een noodzaak van vrijwel elke toepassing. Het proces voor het converteren van een document vanuit een interne in-memory weergave naar een extern gegevensarchief wordt serialisatie aangeduid. Het omgekeerde proces van het lezen van een gegevensarchief en het opnieuw maken van het oorspronkelijke in-memory exemplaar wordt deserialisatie aangeduid.

Over documentserialisatie

Idealiter is het proces van het serialiseren en deserialiseren van een document uit het geheugen en vervolgens weer terug in het geheugen transparant voor de applicatie. De toepassing roept een serializer-methode "schrijven" aan om het document op te slaan, terwijl een deserializer-methode "lezen" toegang heeft tot de gegevensopslag en het oorspronkelijke exemplaar opnieuw in het geheugen maakt. De specifieke indeling waarin de gegevens zijn opgeslagen, is over het algemeen geen probleem van de toepassing zolang het serialiseren en deserialiseren van het document het oorspronkelijke formulier opnieuw maakt.

Toepassingen bieden vaak meerdere serialisatieopties waarmee de gebruiker documenten op een ander medium of in een andere indeling kan opslaan. Een toepassing kan bijvoorbeeld opties voor Opslaan als bieden om een document op te slaan in een schijfbestand, database of webservice. Op dezelfde manier kunnen verschillende serializers het document opslaan in verschillende indelingen, zoals HTML, RTF, XML, XPS of een andere indeling van derden. Voor de toepassing definieert serialisatie een interface waarmee de details van het opslagmedium worden geïsoleerd binnen de implementatie van elke specifieke serializer. Naast de voordelen van het inkapselen van opslagdetails, bieden de .NET Framework-API's System.Windows.Documents.Serialization verschillende andere belangrijke functies.

Functies van .NET Framework 3.0-documentserialisaties

Directe toegang tot de documentobjecten op hoog niveau (logische structuur en visuals) maken efficiënte opslag van gepagineerde inhoud, 2D/3D-elementen, afbeeldingen, media, hyperlinks, aantekeningen en andere ondersteuningsinhoud mogelijk.
Synchrone en asynchrone bewerking.
Ondersteuning voor plug-in-serializers met verbeterde functionaliteiten:
- Systeembrede toegang voor gebruik door alle .NET Framework-toepassingen.
- Eenvoudige vindbaarheid van invoegtoepassingen.
- Eenvoudige implementatie, installatie en update voor aangepaste invoegtoepassingen van derden.
- Gebruikersinterfaceondersteuning voor aangepaste runtime-instellingen en opties.

XPS-afdrukpad

Het microsoft .NET Framework XPS-afdrukpad biedt ook een uitbreidbaar mechanisme voor het schrijven van documenten via afdrukuitvoer. XPS fungeert als een documentbestandsindeling en is de systeemeigen afdrukspoolindeling voor Windows Vista. XPS-documenten kunnen rechtstreeks worden verzonden naar XPS-compatibele printers zonder dat er conversie naar een tussenliggende indeling nodig is. Zie het afdrukoverzicht voor meer informatie over uitvoeropties en mogelijkheden voor afdrukpaden.

Serializers voor invoegtoepassingen

De System.Windows.Documents.Serialization API's bieden ondersteuning voor zowel invoegtoepassingsserialisaties als gekoppelde serialisatieprogramma's die afzonderlijk van de toepassing zijn geïnstalleerd, verbinden tijdens runtime en worden geopend met behulp van het SerializerProvider detectiemechanisme. Invoegtoepassingsserialisaties bieden verbeterde voordelen voor het gemak van implementatie en systeembreed gebruik. Gekoppelde serializers kunnen ook worden geïmplementeerd voor gedeeltelijke vertrouwensomgevingen, zoals XAML-browsertoepassingen (XBAPs), waarbij invoegtoepassingsserialisaties niet toegankelijk zijn. Gekoppelde serializers, die zijn gebaseerd op een afgeleide implementatie van de SerializerWriter klasse, worden gecompileerd en rechtstreeks aan de toepassing gekoppeld. Zowel invoegtoepassingsserialisaties als gekoppelde serialisatieprogramma's werken via identieke openbare methoden en gebeurtenissen, waardoor het gebruik van of beide soorten serializers in dezelfde toepassing eenvoudig is.

Invoegtoepassingsserialisaties helpen ontwikkelaars van toepassingen door uitbreidbaarheid te bieden aan nieuwe opslagontwerpen en bestandsindelingen zonder dat ze rechtstreeks hoeven te coderen voor elke mogelijke indeling tijdens de build. Serializers van invoegtoepassingen profiteren ook van externe ontwikkelaars door een gestandaardiseerde methode te bieden voor het implementeren, installeren en bijwerken van invoegtoepassingen die toegankelijk zijn voor aangepaste of eigen bestandsindelingen.

Een invoegtoepassingsserializer gebruiken

Serializers voor invoegtoepassingen zijn eenvoudig te gebruiken. De SerializerProvider klasse inventariseert een SerializerDescriptor object voor elke invoegtoepassing die op het systeem is geïnstalleerd. De IsLoadable eigenschap filtert de geïnstalleerde invoegtoepassingen op basis van de huidige configuratie en controleert of de serializer kan worden geladen en gebruikt door de toepassing. Het SerializerDescriptor biedt ook andere eigenschappen, zoals DisplayName en DefaultFileExtension, die de toepassing kan gebruiken om de gebruiker te vragen een serializer te selecteren voor een beschikbare uitvoerindeling. Een standaard plug-in-serializer voor XPS wordt meegeleverd met .NET Framework en wordt altijd opgenomen. Nadat de gebruiker een uitvoerindeling heeft geselecteerd, wordt de CreateSerializerWriter methode gebruikt om een SerializerWriter voor de specifieke indeling te maken. De SerializerWriter.Write methode kan vervolgens worden aangeroepen om de documentstream naar het gegevensarchief uit te voeren.

In het volgende voorbeeld ziet u een toepassing die gebruikmaakt van de SerializerProvider methode in een eigenschap PlugInFileFilter. PlugInFileFilter inventariseert de geïnstalleerde invoegtoepassingen en bouwt een filtertekenreeks met de beschikbare bestandsopties voor een 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;
    }
}

Nadat een uitvoerbestandsnaam is geselecteerd door de gebruiker, illustreert het volgende voorbeeld het gebruik van de methode voor het CreateSerializerWriter opslaan van een bepaald document in een opgegeven indeling.

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

Plug-in-serializers installeren

De SerializerProvider klasse levert de toepassingsinterface op het hoogste niveau voor detectie en toegang van de plug-in serializer. SerializerProvider zoekt en biedt de toepassing een lijst met de serializers die zijn geïnstalleerd en toegankelijk zijn op het systeem. De specifieke kenmerken van de geïnstalleerde serializers worden gedefinieerd via registerinstellingen. Serializers voor invoegtoepassingen kunnen aan het register worden toegevoegd met behulp van de RegisterSerializer methode. Als .NET Framework nog niet is geïnstalleerd, kan het installatiescript van de invoegtoepassing de registerwaarden zelf rechtstreeks instellen. De UnregisterSerializer methode kan worden gebruikt om een eerder geïnstalleerde invoegtoepassing te verwijderen, of de registerinstellingen kunnen op dezelfde manier opnieuw worden ingesteld door een installatiescript.

Een invoegtoepassingsserialisatie maken

Zowel invoegtoepassingsserialisaties als gekoppelde serialisatieprogramma's gebruiken dezelfde openbare methoden en gebeurtenissen, en kunnen op dezelfde manier worden ontworpen om synchroon of asynchroon te werken. Er zijn drie basisstappen die normaal gesproken worden gevolgd om een serialisatiefunctie voor invoegtoepassingen te maken:

Implementeer en debug de serializer eerst als een gekoppelde serializer. Het maken van de serialisatiefunctie die rechtstreeks in een testtoepassing is gecompileerd en gekoppeld, biedt volledige toegang tot onderbrekingspunten en andere foutopsporingsservices die nuttig zijn voor het testen.
Nadat de serializer volledig is getest, wordt er een ISerializerFactory interface toegevoegd om een invoegtoepassing te maken. De ISerializerFactory interface biedt volledige toegang tot alle .NET Framework-objecten die de logische structuur, UIElement IDocumentPaginatorSourceobjecten en Visual elementen bevatten. ISerializerFactory Daarnaast biedt u dezelfde synchrone en asynchrone methoden en gebeurtenissen die worden gebruikt door gekoppelde serializers. Omdat het uitvoeren van grote documenten enige tijd kan duren, wordt asynchrone bewerkingen aanbevolen om responsieve gebruikersinteractie te behouden en een optie 'Annuleren' te bieden als er een probleem optreedt met het gegevensarchief.
Nadat de invoegtoepassingsserialisatie is gemaakt, wordt een installatiescript geïmplementeerd voor het distribueren en installeren van de invoegtoepassing (en het verwijderen) (zie hierboven" Plug-in Serializers installeren).

Zie ook

Feedback

Is deze pagina nuttig?

Last updated on 2025-05-07