Serialização e Armazenamento de Documento
O Microsoft .NET Framework fornece um ambiente poderoso para criar e exibir documentos de alta qualidade. Recursos avançados de suporte a documentos de fluxo fixo e livre, controles de exibição avançados, combinados com poderosos recursos gráficos 2D e 3D levam aplicativos .NET Framework a um novo nível de qualidade e de experiência do usuário. Poder gerenciar de maneira flexível a representação em memória de um documento é um recurso chave do .NET Framework, e ser capaz de salvar e carregar documentos de forma eficiente a partir de uma área de armazenamento de dados é uma necessidade de quase todo aplicativo. O processo de conversão de um documento de uma representação interna em memória em um para armazenamento de dados externo é chamado de serialização. O processo inverso, de ler um armazenamento de dados e recriar a instância original em memória, é chamado desserialização.
Este tópico contém as seguintes seções.
- Sobre serialização de documentos.
- Plug-ins serializadores
- Tópicos relacionados
Sobre serialização de documentos.
O ideal é que o processo de serialização e desserialização de um documento seja transparente para o aplicativo. O aplicativo chama um método “gravar” do serializador para salvar o documento, enquanto a desserialização usa um método “ler” para acessar a área de armazenamento de dados e recriar a instância original em memória. O formato específico em que os dados são armazenados geralmente não é uma preocupação do aplicativo, desde que o processo de serialização e desserialização recrie o documento em sua forma original.
Os aplicativos geralmente fornecem várias opções de serialização que permitem que o usuário salve documentos em mídias diferentes ou em um formato diferente. Por exemplo, um aplicativo pode oferecer opções “ Salvar como ” para armazenar um documento em um arquivo no disco, banco de dados ou Serviço Web. Da mesma forma, diferentes serializadores poderiam armazenar o documento em diferentes formatos, como HTML, RTF, XML, XPS ou em um formato de terceiros. Para o aplicativo a serialização define uma interface que isola os detalhes da mídia de armazenamento dentro da implementação de cada serializador específico. Além dos benefícios do encapsulamento dos detalhes de armazenamento, as APIs System.Windows.Documents.Serialization do .NET Framework fornecem várias outros recursos importantes.
Recursos dos serializadores de documento do .NET Framework 3.0
O acesso direto aos objetos de alto nível do documento (árvore lógica e elementos visuais) permite um armazenamento eficiente de conteúdo paginado, elementos 2D/3D, imagens, mídia, hiperlinks, anotações e outros conteúdos de suporte.
Operação síncrona e assíncrona.
Suporte a serializadores plug-in com recursos avançados:
Acesso de todo o sistema para uso por todos os aplicativos .NET Framework.
Descoberta simples de plug-ins de aplicativo.
Implantação, instalação e atualização simples de plug-ins personalizados de terceiros.
Suporte da interface do usuário a configurações e opções personalizadas em tempo de execução.
Caminho de Impressão XPS
The Microsoft .NET Framework XPS print path also provides an extensible mechanism for writing documents through print output. XPS serve sistema autônomo formato de arquivo de documento e é o formato de spool de impressão nativo para Windows Vista. XPS os documentos podem ser enviados diretamente para XPS-compatível com impressoras sem a necessidade de conversão para um formato de intermediário. Consulte Visão Geral de Impressão para obter informações adicionais sobre opções de saída e recursos de caminhos de impressão.
Plug-ins serializadores
As APIs System.Windows.Documents.Serialization fornecem suporte a serializadores via ligação (link) e serializadores via plug-in que são instalados separadamente do aplicativo, associados em tempo de execução e são acessados usando o mecanismo de descoberta SerializerProvider. Plug-in serializadores oferecem benefícios maiores para uma fácil implantação e uso por todo o sistema. Serializadores via ligação também podem ser implementados para ambientes de confiança parcial, como aplicativos de navegador XAML (XBAPs), onde plug-ins serializadores não são acessíveis. Serializadores via ligação, que são baseados em uma implementação derivada da classe SerializerWriter, são compilados e ligados diretamente ao aplicativo. Plug-ins serializadores e serializadores via ligação operam através de métodos públicos e eventos idênticos, que facilitam o uso de um ou de ambos os tipos de serializadores no mesmo aplicativo.
Plug-ins serializadores ajudam os desenvolvedores de aplicativos fornecendo extensibilidade para novos projetos de armazenamento e formatos de arquivo, sem que seja necessário gerar código diretamente para cada formato em potencial no momento da compilação. Plug-ins serializadores também beneficiam desenvolvedores terceiros ao fornecer um meio padronizado para implantar, instalar e atualizar plug-ins acessíveis pelo sistema para formatos de arquivo personalizados ou proprietários.
Usando um plug-in serializador
Plug-ins serializadores são simples de usar. A classe SerializerProvider enumera um objeto SerializerDescriptor para cada plug-in instalado no sistema. A propriedade IsLoadable filtra os plug-ins instalados com base na configuração atual e verifica se o serializador pode ser carregado e usado pelo aplicativo. O SerializerDescriptor também oferece outras propriedades, como DisplayName e DefaultFileExtension, que o aplicativo pode usar quando solicitar ao usuário que selecione um serializador para um formato de saída disponível. Um serializador plug-in padrão para XPS é fornecido com o .NET Framework e é sempre enumerado. Após o usuário selecionar um formato de saída, o método CreateSerializerWriter é usado para criar um SerializerWriter para o formato específico. O método SerializerWriter.Write pode então ser chamado para dar saída ao fluxo de dados do documento para a área de armazenamento de dados.
O exemplo a seguir ilustra um aplicativo que usa o método SerializerProvider em uma propriedade “PlugInFileFilter”. PlugInFileFilter enumera os plug-ins instalados e cria uma sequência de caracteres filtro com as opções de arquivo disponíveis para um 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;
}
}
Após um nome de arquivo de saída ser selecionado pelo usuário, o exemplo a seguir ilustra o uso do método CreateSerializerWriter para guardar um dado documento em um formato especificado. For the complete example, see Exemplo de serialização do documento.
// 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;
}
Instalando plug-ins serializadores
The SerializerProvider classe fornece a interface de aplicativo de nível superior de descoberta de serializador de plug-in e acesso. SerializerProvider Localiza e fornece o aplicativo de uma lista de serializadores que estão instalados e acessíveis no sistema. As especificidades dos serializadores instalados são definidas por meio de configurações do Registro. Serializadores via plug-in podem ser adicionados ao Registro usando o método RegisterSerializer; ou se o .NET Framework ainda não estiver instalado, o script de instalação do plug-in pode definir diretamente os valores do Registro. O método UnregisterSerializer pode ser usado para remover um plug-in anteriormente instalado, ou as configurações do Registro podem ser redefinidas de maneira semelhante por um script de desinstalação.
Criando um plug-in serializador
Plug-ins serializadores e serializadores via ligação usam os mesmos métodos públicos e eventos expostos e, da mesma forma, podem ser projetados para operar de forma síncrona ou assíncrona. Há três etapas básicas normalmente seguidas para se criar um serializador via plug-in:
Implemente e depure o serializador primeiramente como um serializador via ligação. Criar inicialmente o serializador via compilação e ligação diretamente a um aplicativo de teste fornece acesso completo a pontos de interrupção e outros serviços de depuração úteis para teste.
Depois que o serializador foi totalmente testado, um ISerializerFactory interface é adicionada ao criar um plug-in. The ISerializerFactory interface permite acesso completo a todos os .NET Framework objetos que inclui a árvore lógica, UIElement objetos, IDocumentPaginatorSource, e Visual elementos. Além disso, ISerializerFactory fornece os mesmos eventos e métodos síncronos e assíncronos utilizados por serializadores via ligação. Já que documentos grandes podem levar tempo para ser enviados a saída, operações assíncronas são recomendadas para manter uma boa resposta para a interação do usuário e oferecer uma opção “Cancelar” se ocorrer algum problema com o armazenamento de dados.
Depois que o plug-in serializador for criado, um script de instalação é implementado para distribuir e instalar (e desinstalar) o plug-in (consulte a seção “Instalação de plug-ins serializadores ” acima).
Consulte também
Tarefas
Exemplo de serialização do documento
Conceitos
Documentos em Windows Presentation Foundation
Referência
System.Windows.Documents.Serialization