Dela via

Dokumentserialisering och lagring

Microsoft .NET Framework tillhandahåller en kraftfull miljö för att skapa och visa högkvalitativa dokument. Förbättrade funktioner som stöder både fasta dokument och flödesdokument, avancerade visningskontroller i kombination med kraftfulla 2D- och 3D-grafiska funktioner tar .NET Framework-program till en ny nivå av kvalitet och användarupplevelse. Att kunna hantera en minnesintern representation av ett dokument på ett flexibelt sätt är en viktig funktion i .NET Framework, och att effektivt kunna spara och läsa in dokument från ett datalager är ett behov av nästan alla program. Processen att konvertera ett dokument från en intern minnesintern representation till ett externt datalager kallas serialisering. Den omvända processen att läsa ett datalager och återskapa den ursprungliga minnesinterna instansen kallas deserialisering.

Om dokumentserierering

Helst är processen för serialisering och deserialisering av ett dokument från och sedan tillbaka till minnet transparent för programmet. Programmet anropar en serialiserare för att spara dokumentet, medan en deserialiserare "läs"-metod kommer åt datalagret och återskapar den ursprungliga instansen i minnet. Det specifika format som data lagras i är vanligtvis inte ett problem för programmet så länge serialisera och deserialisera processen återskapar dokumentet tillbaka till sitt ursprungliga formulär.

Program tillhandahåller ofta flera serialiseringsalternativ som gör att användaren kan spara dokument på olika medium eller till ett annat format. Ett program kan till exempel erbjuda "Spara som"-alternativ för att lagra ett dokument i en diskfil, databas eller webbtjänst. På samma sätt kan olika serialiserare lagra dokumentet i olika format, till exempel i HTML, RTF, XML, XPS eller alternativt i ett format från tredje part. För programmet definierar serialiseringen ett gränssnitt som isolerar information om lagringsmediet inom implementeringen av varje specifik serialiserare. Förutom fördelarna med att kapsla in lagringsinformation tillhandahåller .NET Framework System.Windows.Documents.Serialization API:er flera andra viktiga funktioner.

Funktioner i .NET Framework 3.0-dokumentserialiserare

  • Direkt åtkomst till dokumentobjekt på hög nivå (logiskt träd och visuella objekt) möjliggör effektiv lagring av sidnumrerat innehåll, 2D/3D-element, bilder, media, hyperlänkar, anteckningar och annat stödinnehåll.

  • Synkron och asynkron åtgärd.

  • Stöd för plugin-serialiserare med förbättrade funktioner:

    • Systemomfattande åtkomst för användning av alla .NET Framework-program.

    • Enkel plugin-upptäckbarhet.

    • Enkel distribution, installation och uppdatering för anpassade plugin-program från tredje part.

    • Stöd för användargränssnittet för anpassade inställningar och alternativ vid körning.

XPS-utskriftsväg

Microsoft .NET Framework XPS-utskriftsvägen ger också en utbyggbar mekanism för att skriva dokument via utskriftsutdata. XPS fungerar både som ett dokumentfilformat och är det interna utskriftspoolformatet för Windows Vista. XPS-dokument kan skickas direkt till XPS-kompatibla skrivare utan att du behöver konvertera till ett mellanliggande format. Mer information om utskriftsalternativ och kapacitet finns i Utskriftsöversikt.

Serialiserare för plugin-program

Dessa System.Windows.Documents.Serialization API:er ger stöd för både plugin-serialiserare och länkade serialiserare som installeras separat från applikationen, kopplas vid körning och nås med hjälp av SerializerProvider-upptäcktsmekanismen. Plugin-serialiserare ger förbättrade fördelar för enkel distribution och systemomfattande användning. Länkade serialiserare kan också implementeras för partiella förtroendemiljöer, till exempel XAML-webbläsarprogram (XBAPs) där plugin-serialiserare inte är tillgängliga. Länkade serialiserare, som baseras på en härledd implementering av klassen SerializerWriter, kompileras och länkas direkt till programmet. Både plugin-serialiserare och länkade serialiserare fungerar med identiska offentliga metoder och händelser som gör det enkelt att använda någon av eller båda typerna av serialiserare i samma program.

Plugin-serialiserare hjälper programutvecklare genom att ge utökningsbarhet till nya lagringsdesigner och filformat utan att behöva koda direkt för varje potentiellt format vid byggtiden. Plugin-serialiserare gynnar även tredjepartsutvecklare genom att tillhandahålla ett standardiserat sätt att distribuera, installera och uppdatera systemtillgängliga plugin-program för anpassade eller egna filformat.

Använda en plugin-serialiserare

Plugin-serialiserare är enkla att använda. Klassen SerializerProvider räknar upp ett SerializerDescriptor objekt för varje plugin-program som är installerat på systemet. Egenskapen IsLoadable filtrerar de installerade plugin-programmen baserat på den aktuella konfigurationen och verifierar att serialiseraren kan läsas in och användas av programmet. SerializerDescriptor innehåller även andra egenskaper, till exempel DisplayName och DefaultFileExtension, som programmet kan använda för att uppmana användaren att välja en serialiserare för ett tillgängligt utdataformat. En standard-plugin-serialiserare för XPS tillhandahålls med .NET Framework och räknas alltid upp. När användaren har valt ett utdataformat används metoden CreateSerializerWriter för att skapa en SerializerWriter för det specifika formatet. Metoden SerializerWriter.Write kan sedan anropas för att mata ut dokumentströmmen till datalagret.

I följande exempel visas ett program som använder metoden SerializerProvider i egenskapen "PlugInFileFilter". PlugInFileFilter räknar upp de installerade plugin-programmen och skapar en filtersträng med tillgängliga filalternativ för en 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;
    }
}

När ett utdatafilnamn har valts av användaren illustrerar följande exempel användningen av metoden CreateSerializerWriter för att lagra ett visst dokument i ett angivet 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;
}

Installera insticksmodulserialiserare

Klassen SerializerProvider tillhandahåller det övre programgränssnittet för identifiering och åtkomst av plugin-program serialiserare. SerializerProvider letar upp och tillhandahåller programmet en lista över serialiserare som är installerade och tillgängliga i systemet. Detaljerna för de installerade serialiserarna definieras via registerinställningar. Plugin-serialiserare kan läggas till i registret med hjälp av metoden RegisterSerializer. eller om .NET Framework ännu inte har installerats kan plugin-installationsskriptet direkt ange själva registervärdena. Metoden UnregisterSerializer kan användas för att ta bort ett tidigare installerat plugin-program, eller så kan registerinställningarna återställas på samma sätt av ett avinstallationsskript.

Skapa en plugin-serialiserare

Både plugin-serialiserare och länkade serialiserare använder samma exponerade offentliga metoder och händelser, och på samma sätt kan de utformas för att fungera synkront eller asynkront. Det finns tre grundläggande steg som normalt följs för att skapa en plugin-serialiserare:

  1. Implementera och felsök först serialiseraren som en länkad serialiserare. När du först skapar serialiseraren som kompilerats och länkats direkt i ett testprogram får du fullständig åtkomst till brytpunkter och andra felsökningstjänster som är användbara för testning.

  2. När serialiseraren har testats fullständigt läggs ett ISerializerFactory-gränssnitt till för att skapa ett plugin-program. Gränssnittet ISerializerFactory tillåter fullständig åtkomst till alla .NET Framework-objekt som innehåller det logiska trädet, UIElement objekt, IDocumentPaginatorSourceoch Visual element. Dessutom tillhandahåller ISerializerFactory samma synkrona och asynkrona metoder och händelser som används av länkade serialiserare. Eftersom stora dokument kan ta tid att mata ut, rekommenderas asynkrona åtgärder för att upprätthålla dynamisk användarinteraktion och erbjuda ett "Avbryt"-alternativ om något problem uppstår med datalagret.

  3. När plugin-serialiseraren har skapats implementeras ett installationsskript för att distribuera och installera (och avinstallera) plugin-programmet (se ovan"Installera plugin-serialiserare").

Se även