Serializzazione e archiviazione di documenti
Aggiornamento: novembre 2007
Microsoft .NET Framework offre un ambiente avanzato per la creazione e la visualizzazione di documenti di alta qualità. Funzionalità avanzate che supportano documenti sia statici sia dinamici e controlli di visualizzazione avanzati combinati con potenti funzionalità grafiche 2D e 3D consentono la creazione di applicazioni .NET Framework di livello elevato in termini di qualità ed esperienza utente. La possibilità di gestire in modo flessibile la rappresentazione in memoria di un documento è una funzionalità chiave di .NET Framework e la capacità di salvare e caricare documenti in modo efficiente da un archivio dati è l'esigenza di ogni applicazione. Il processo di conversione di un documento da una rappresentazione in memoria interna a un archivio dati esterno è detto serializzazione. Il processo inverso di lettura di un archivio dati e creazione dell'istanza in memoria originale è detto deserializzazione.
Nel presente argomento sono contenute le seguenti sezioni.
- Informazioni sulla serializzazione di documenti
- Serializzatori plug-in
- Argomenti correlati
Informazioni sulla serializzazione di documenti
In teoria, il processo di serializzazione e deserializzazione di un documento in memoria è trasparente all'applicazione. L'applicazione chiama un metodo di scrittura del serializzatore per salvare il documento, mentre un metodo di lettura del deserializzatore accede all'archivio dati e crea nuovamente l'istanza originale in memoria. Il formato specifico in cui vengono archiviati i dati non costituisce in genere motivo di preoccupazione per l'applicazione, purché il processo di serializzazione e deserializzazione ricrei il documento nel formato originale.
Nelle applicazioni sono spesso disponibili varie opzioni di serializzazione che consentono all'utente di salvare documenti in supporti o formati diversi. Ad esempio, è possibile che in un'applicazione siano disponibili opzioni Salva con nome per l'archiviazione di un file su disco, in un database o come servizio Web. Allo stesso modo, serializzatori diversi potrebbero archiviare il documento in formati diversi quali HTML, RTF, XML, XPS o, in alternativa, in un formato di terze parti. Per l'applicazione, la serializzazione definisce un'interfaccia che isola i dettagli del supporto di archiviazione nell'implementazione di ogni specifico serializzatore. Oltre ai vantaggi offerti dalla possibilità di incapsulare i dettagli di archiviazione, le APISystem.Windows.Documents.Serialization.NET Framework forniscono altre importanti funzionalità.
Funzionalità dei serializzatori di documenti di .NET Framework 3.0
L'accesso diretto agli oggetti documento di alto livello (albero logico ed elementi 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 disponibile da tutte le applicazioni .NET Framework.
Individuazione semplice dei plug-in dell'applicazione.
Facilità di distribuzione, installazione e aggiornamento per i plug-in di terze parti personalizzati.
Supporto dell'interfaccia utente per impostazioni e opzioni di runtime personalizzate.
Percorso di stampa XPS
Il percorso di stampa XPS di Microsoft .NET Framework offre inoltre un meccanismo estensibile per la scrittura di documenti tramite l'output di stampa. XPS funge sia da formato di file di documento sia da formato di spooling nativo per documenti Windows Vista. I documenti XPS possono essere inviati direttamente alle stampanti compatibili con XPS senza la necessità di conversione in un formato intermedio. Per ulteriori informazioni sulle opzioni e le funzionalità dell'output del percorso di stampa, vedere Cenni preliminari sulla stampa.
Serializzatori plug-in
Le API System.Windows.Documents.Serialization offrono supporto per serializzatori plug-in e serializzatori collegati installati separatamente dall'applicazione, associati in fase di esecuzione e a cui si accede utilizzando il meccanismo di individuazione di SerializerProvider. I serializzatori plug-in offrono notevoli vantaggi in termini di facilità di distribuzione e utilizzo a livello di sistema. I serializzatori collegati possono anche essere implementati per ambienti parzialmente attendibili, ad esempio applicazioni applicazione browser XAML (XBAP) in cui non sono accessibili serializzatori plug-in. I serializzatori collegati, basati su un'implementazione derivata della classe SerializerWriter, vengono compilati e collegati direttamente nell'applicazione. Sia i serializzatori plug-in, sia i serializzatori collegati funzionano tramite eventi e metodi pubblici identici che semplificano l'utilizzo di uno o di entrambi i tipi di serializzatori nella stessa applicazione.
I serializzatori plug-in offrono agli sviluppatori di applicazioni estensibilità per nuovi progetti di archiviazione e formati di file senza la necessità di scrivere direttamente codice per ogni potenziale formato in fase di compilazione. I serializzatori plug-in sono inoltre utili agli sviluppatori di terze parti in quanto forniscono un mezzo standardizzato per distribuire, installare e aggiornare plug-in accessibili al sistema per formati di file personalizzati o proprietari.
Utilizzo di un serializzatore plug-in
I serializzatori plug-in sono semplici da utilizzare. 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 utilizzato dall'applicazione. L'oggetto SerializerDescriptor fornisce anche altre proprietà, quali DisplayName e DefaultFileExtension, che possono essere utilizzate dall'applicazione per richiedere all'utente la selezione di un serializzatore per un formato di output disponibile. Un serializzatore plug-in predefinito per XPS viene fornito con .NET Framework ed è sempre enumerato. Dopo la selezione di un formato di output da parte dell'utente, viene utilizzato il metodo CreateSerializerWriter per creare un oggetto SerializerWriter per il formato specifico. È quindi possibile chiamare il metodo SerializerWriter.Write per restituire il flusso del documento all'archivio dati.
Nell'esempio riportato di seguito viene illustrata un'applicazione che utilizza il metodo SerializerProvider in una proprietà PlugInFileFilter. Questa proprietà enumera i plug-in installati e compila una stringa di filtro con le opzioni di file disponibili per un oggetto 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 la selezione di un nome file di output da parte dell'utente, nell'esempio riportato di seguito viene illustrato l'utilizzo del metodo CreateSerializerWriter per archiviare un determinato documento in un formato specificato. Per l'esempio completo, vedere Esempio di serializzazione di documenti.
// 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 l'individuazione e l'accesso al serializzatore 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. È possibile aggiungere i serializzatori plug-in al Registro di sistema tramite il metodo RegisterSerializer. In alternativa, se .NET Framework non è ancora installato, è possibile impostare direttamente i valori del Registro di sistema tramite lo script di installazione del plug-in. È possibile utilizzare il metodo UnregisterSerializer per rimuovere un plug-in installato in precedenza oppure reimpostare le impostazioni del Registro di sistema in modo analogo tramite uno script di disinstallazione.
Creazione di un serializzatore plug-in
Sia i serializzatori plug-in sia i serializzatori collegati utilizzano gli stessi eventi e metodi pubblici esposti e possono essere progettati in modo analogo per funzionare in modalità sincrona o asincrona. Sono tre i passaggi in genere eseguiti per creare un serializzatore plug-in:
Implementare ed eseguire il debug del serializzatore innanzitutto come serializzatore collegato. La creazione iniziale di un serializzatore compilato e collegato direttamente in un'applicazione di prova consente l'accesso completo ai punti di interruzione e ad altri servizi di debug utili ai fini di test.
Dopo il test completo del serializzatore, viene aggiunta un'interfaccia ISerializerFactory per creare un plug-in. L'interfaccia ISerializerFactory offre l'accesso completo a tutti gli oggetti .NET Framework che includono l'albero logico, agli oggetti UIElement e agli elementi IDocumentPaginatorSource e Visual. Inoltre, ISerializerFactory fornisce gli stessi metodi ed eventi sincroni e asincroni utilizzati dai serializzatori collegati. Poiché l'output dei documenti di grandi dimensioni richiede tempo, le operazioni asincrone sono consigliate per garantire l'interazione dell'utente e fornire un'opzione "Annulla" se si verifica un problema relativo all'archivio dati.
Dopo la creazione del serializzatore plug-in, viene implementato uno script di installazione per la distribuzione e l'installazione e la disinstallazione del plug-in (vedere la sezione precedente "Installazione di serializzatori plug-in").
Vedere anche
Attività
Esempio di serializzazione di documenti
Concetti
Documenti di Windows Presentation Foundation
Cenni preliminari sulla stampa
Riferimenti
System.Windows.Documents.Serialization