Serializzazione e archiviazione dei documenti

Articolo
12/19/2024

Microsoft .NET Framework offre un ambiente potente per la creazione e la visualizzazione di documenti di alta qualità. Funzionalità avanzate che supportano documenti fissi e documenti di flusso, controlli di visualizzazione avanzati, combinati con potenti funzionalità grafiche 2D e 3D portano le applicazioni .NET Framework a un nuovo livello di qualità e esperienza utente. La possibilità di gestire in modo flessibile una rappresentazione in memoria di un documento è una funzionalità chiave di .NET Framework e la possibilità di salvare e caricare in modo efficiente i documenti da un archivio dati è una necessità di quasi ogni applicazione. Il processo di conversione di un documento da una rappresentazione interna in memoria in un archivio dati esterno è definito serializzazione. Il processo inverso di lettura di un archivio dati e la ricreazione dell'istanza originale in memoria è detta deserializzazione.

Informazioni sulla serializzazione dei documenti

Idealmente, il processo di serializzazione e deserializzazione di un documento da memoria e poi nuovamente in essa è trasparente per l'applicazione. L'applicazione chiama un metodo di "scrittura" del serializzatore per salvare il documento, mentre un metodo di deserializzazione "read" accede all'archivio dati e ricrea l'istanza originale in memoria. Il formato specifico in cui vengono archiviati i dati non è in genere un problema dell'applicazione, purché il processo di serializzazione e deserializzazione ricrea il documento nel formato originale.

Le applicazioni spesso offrono più opzioni di serializzazione che consentono all'utente di salvare i documenti in un supporto diverso o in un formato diverso. Ad esempio, un'applicazione potrebbe offrire opzioni "Salva con nome" per archiviare un documento in un file, un database o un servizio Web su disco. Analogamente, i serializzatori diversi possono archiviare il documento in formati diversi, ad esempio IN HTML, RTF, XML, XPS o in alternativa a un formato di terze parti. Per l'applicazione, la serializzazione definisce un'interfaccia che isola i dettagli del supporto di archiviazione all'interno dell'implementazione di ogni serializzatore specifico. Oltre ai vantaggi dell'incapsulamento dei dettagli dell'archiviazione, le API di .NET Framework System.Windows.Documents.Serialization offrono diverse altre funzionalità importanti.

Funzionalità dei serializzatori di documenti di .NET Framework 3.0

L'accesso diretto agli oggetti documento di alto livello (albero logico e oggetti visivi) consente di archiviare in modo efficiente contenuto impaginato, elementi 2D/3D, immagini, supporti, collegamenti ipertestuali, annotazioni e altro contenuto di supporto.
Operazione sincrona e asincrona.
Supporto per serializzatori plug-in con funzionalità avanzate:
- Accesso a livello di sistema per l'uso da parte di tutte le applicazioni .NET Framework.
- Semplice individuazione dei plug-in dell'applicazione.
- Distribuzione, installazione e aggiornamento semplici per plug-in di terze parti personalizzati.
- Supporto dell'interfaccia utente per impostazioni e opzioni di runtime personalizzate.

Percorso di stampa per XPS

Il percorso di stampa XPS di Microsoft .NET Framework offre anche un meccanismo estendibile per la scrittura di documenti tramite output di stampa. XPS funge sia come formato di file di documenti sia come formato nativo per lo spooling di stampa in Windows Vista. I documenti XPS possono essere inviati direttamente alle stampanti compatibili con XPS senza la necessità di eseguire la conversione in un formato intermedio. Per ulteriori informazioni sulle opzioni e le funzionalità di output del percorso di stampa, vedere la panoramica della stampa .

Serializzatori plugin

Le API di System.Windows.Documents.Serialization forniscono supporto per serializzatori plug-in e serializzatori collegati installati separatamente dall'applicazione, associati in fase di esecuzione e a cui si accede usando il meccanismo di individuazione SerializerProvider. I serializzatori plug-in offrono vantaggi avanzati per semplificare la distribuzione e l'uso a livello di sistema. I serializzatori collegati possono essere implementati anche per ambienti con attendibilità parziale, ad esempio applicazioni browser XAML (XBAP) in cui i serializzatori plug-in non sono accessibili. I serializzatori collegati, basati su un'implementazione derivata della classe SerializerWriter, vengono compilati e collegati direttamente nell'applicazione. Sia i serializzatori plug-in che i serializzatori collegati funzionano tramite metodi e eventi pubblici identici che semplificano l'uso di entrambi i tipi di serializzatori nella stessa applicazione.

I serializzatori plug-in aiutano gli sviluppatori di applicazioni fornendo estendibilità ai nuovi formati di archiviazione e file senza dover scrivere codice direttamente per ogni potenziale formato in fase di compilazione. I serializzatori plug-in traggono vantaggio anche dagli sviluppatori di terze parti fornendo un mezzo standardizzato per distribuire, installare e aggiornare i plug-in accessibili del sistema per formati di file personalizzati o proprietari.

Uso di un serializzatore plugin

I serializzatori plug-in sono semplici da usare. La classe SerializerProvider enumera un oggetto SerializerDescriptor per ogni plug-in installato nel sistema. La proprietà IsLoadable filtra i plug-in installati in base alla configurazione corrente e verifica che il serializzatore possa essere caricato e usato dall'applicazione. Il SerializerDescriptor fornisce anche altre proprietà, ad esempio DisplayName e DefaultFileExtension, che l'applicazione può usare per richiedere all'utente di selezionare un serializzatore per un formato di output disponibile. Un serializzatore di plug-in predefinito per XPS viene fornito con .NET Framework ed è sempre elencato. Dopo aver selezionato un formato di output, viene usato il metodo CreateSerializerWriter per creare un SerializerWriter per il formato specifico. Il metodo SerializerWriter.Write può quindi essere chiamato per restituire il flusso di documenti nell'archivio dati.

Nell'esempio seguente viene illustrata un'applicazione che usa il metodo SerializerProvider in una proprietà "PlugInFileFilter". PlugInFileFilter enumera i plug-in installati e compila una stringa di filtro con le opzioni di file disponibili per un 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;
    }
}

Dopo che un nome di file di output è stato selezionato dall'utente, nell'esempio seguente viene illustrato l'uso del metodo CreateSerializerWriter per archiviare un determinato documento in un formato specificato.

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

Installazione di serializzatori plug-in

La classe SerializerProvider fornisce l'interfaccia dell'applicazione di livello superiore per la scoperta e l'accesso ai serializzatori dei plug-in. SerializerProvider individua e fornisce all'applicazione un elenco dei serializzatori installati e accessibili nel sistema. Le specifiche dei serializzatori installati vengono definite tramite le impostazioni del Registro di sistema. I serializzatori plug-in possono essere aggiunti al Registro di sistema usando il metodo RegisterSerializer; oppure se .NET Framework non è ancora installato, lo script di installazione del plug-in può impostare direttamente i valori del Registro di sistema stessi. Il metodo UnregisterSerializer può essere usato per rimuovere un plug-in installato in precedenza oppure le impostazioni del Registro di sistema possono essere reimpostate in modo analogo da uno script di disinstallazione.

Creazione di un serializzatore plug-in

Sia i serializzatori plug-in che i serializzatori collegati usano gli stessi metodi ed eventi pubblici esposti e, analogamente, possono essere progettati per funzionare in modo sincrono o asincrono. Per creare un serializzatore plug-in, sono in genere seguiti tre passaggi di base:

Implementare il serializzatore prima come serializzatore collegato ed eseguirne il debug. La creazione iniziale del serializzatore compilato e collegato direttamente in un'applicazione di test fornisce l'accesso completo ai punti di interruzione e ad altri servizi di debug utili per il test.
Dopo aver testato completamente il serializzatore, viene aggiunta un'interfaccia ISerializerFactory per creare un plug-in. L'interfaccia ISerializerFactory consente l'accesso completo a tutti gli oggetti .NET Framework che includono l'albero logico, gli oggetti UIElement, IDocumentPaginatorSourcee gli elementi Visual. Inoltre, ISerializerFactory fornisce gli stessi metodi e eventi sincroni e asincroni usati dai serializzatori collegati. Poiché i documenti di grandi dimensioni possono richiedere tempo per l'output, le operazioni asincrone sono consigliate per mantenere l'interazione utente reattiva e offrire un'opzione "Annulla" se si verifica un problema con l'archivio dati.
Dopo aver creato il serializzatore plug-in, viene implementato uno script di installazione per la distribuzione e l'installazione (e la disinstallazione) del plug-in (vedere sopra "Installazione di serializzatori plug-in").

Condividi tramite