Partilhar via

Serialização e armazenamento de documentos

  • Artigo

O Microsoft .NET Framework fornece um ambiente poderoso para criar e exibir documentos de alta qualidade. Recursos aprimorados que suportam documentos fixos e documentos de fluxo, controles de visualização avançados, combinados com poderosos recursos gráficos 2D e 3D, levam os aplicativos do .NET Framework a um novo nível de qualidade e experiência do usuário. Ser capaz de gerenciar de forma flexível uma representação na memória de um documento é um recurso fundamental do .NET Framework, e ser capaz de salvar e carregar documentos de forma eficiente de um armazenamento de dados é uma necessidade de quase todos os aplicativos. O processo de conversão de um documento de uma representação interna na memória para um armazenamento de dados externo é denominado serialização. O processo inverso de leitura de um armazenamento de dados e recriação da instância original na memória é denominado desserialização.

Sobre a serialização de documentos

Idealmente, o processo de serialização e desserialização de um documento a partir e de volta para a memória é transparente para a aplicação. O aplicativo chama um método de "gravação" do serializador para salvar o documento, enquanto um método de "leitura" do desserializador acessa o armazenamento de dados e recria a instância original na 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 de volta à sua forma original.

Os aplicativos geralmente fornecem várias opções de serialização que permitem ao usuário salvar documentos em um meio diferente ou em um formato diferente. Por exemplo, um aplicativo pode oferecer opções de "Salvar como" para armazenar um documento em um arquivo de disco, banco de dados ou serviço Web. Da mesma forma, diferentes serializadores podem armazenar o documento em diferentes formatos, como em HTML, RTF, XML, XPS ou alternadamente para 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 de encapsular detalhes de armazenamento, o .NET Framework System.Windows.Documents.Serialization APIs fornecem vários outros recursos importantes.

Recursos dos serializadores de documentos do .NET Framework 3.0

  • O acesso direto aos objetos de documento de alto nível (árvore lógica e visuais) permite o 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 para serializadores de plug-in com recursos aprimorados:

    • Acesso em todo o sistema para uso por todos os aplicativos .NET Framework.

    • Descoberta simples de plug-ins de aplicações.

    • Implantação, instalação e atualização simples para plug-ins personalizados de terceiros.

    • Suporte à interface do usuário para configurações e opções personalizadas de tempo de execução.

Caminho de impressão XPS

O caminho de impressão XPS do Microsoft .NET Framework também fornece um mecanismo extensível para escrever documentos através da saída de impressão. XPS serve como um formato de arquivo de documento e é o formato de spool de impressão nativo para o Windows Vista. Os documentos XPS podem ser enviados diretamente para impressoras compatíveis com XPS sem a necessidade de conversão para um formato intermediário. Consulte a Visão geral da impressão para obter informações adicionais sobre as opções e os recursos de saída do caminho de impressão.

Serializadores de plugins

As APIs System.Windows.Documents.Serialization oferecem suporte tanto a serializadores de plug-in quanto a serializadores conectados que são instalados separadamente da aplicação, são vinculados durante a execução e são acedidos usando o mecanismo de descoberta de SerializerProvider. Os serializadores de plug-in oferecem benefícios aprimorados para facilitar a implantação e o uso em todo o sistema. Os serializadores vinculados também podem ser implementados para ambientes de confiança parcial, como aplicativos de navegador XAML (XBAPs), onde os serializadores de plug-in não estão acessíveis. Os serializadores vinculados, que são baseados em uma implementação derivada da classe SerializerWriter, são compilados e vinculados diretamente ao aplicativo. Ambos os serializadores de plug-in e serializadores vinculados operam através de métodos públicos idênticos e eventos que facilitam o uso de um ou ambos os tipos de serializadores no mesmo aplicativo.

Os serializadores de plug-in ajudam os desenvolvedores de aplicativos fornecendo extensibilidade a novos designs de armazenamento e formatos de arquivo sem ter que codificar diretamente para cada formato potencial no momento da compilação. Os serializadores de plug-in também beneficiam desenvolvedores de terceiros, fornecendo um meio padronizado para implantar, instalar e atualizar plug-ins acessíveis ao sistema para formatos de arquivo personalizados ou proprietários.

Usando um serializador de plug-in

Os serializadores de plug-in 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 fornece outras propriedades, como DisplayName e DefaultFileExtension, que o aplicativo pode usar para solicitar ao usuário a seleção de um serializador para um formato de saída disponível. Um serializador de plug-in padrão para XPS é fornecido com o .NET Framework e é sempre listado. Depois que o usuário seleciona 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 exportar o fluxo de documentos para o 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 que estão instalados e constrói uma cadeia de caracteres de filtro com as opções de ficheiro 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;
    }
}

Depois que um nome de arquivo de saída foi selecionado pelo usuário, o exemplo a seguir ilustra o uso do método CreateSerializerWriter para armazenar um determinado documento em um formato especificado.

// 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 serializadores de plugin

A classe SerializerProvider fornece a interface de aplicativo de nível superior para descoberta e acesso ao serializador de plug-in. SerializerProvider localiza e fornece ao aplicativo uma lista dos serializadores que estão instalados e acessíveis no sistema. As especificidades dos serializadores instalados são definidas através das configurações do Registro. Os serializadores de 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 poderá definir diretamente os próprios valores do Registro. O método UnregisterSerializer pode ser usado para remover um plug-in instalado anteriormente ou as configurações do Registro podem ser redefinidas de forma semelhante por um script de desinstalação.

Criando um serializador de plugin

Os serializadores de plug-in e os serializadores vinculados usam os mesmos métodos e eventos públicos 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 criar um serializador de plug-in:

  1. Implemente e depure o serializador primeiro como um serializador vinculado. A criação inicial do serializador compilado e vinculado diretamente em um aplicativo de teste fornece acesso total a pontos de interrupção e outros serviços de depuração úteis para testes.

  2. Depois que o serializador é totalmente testado, uma interface ISerializerFactory é adicionada para criar um plug-in. A interface ISerializerFactory permite acesso total a todos os objetos do .NET Framework que inclui a árvore lógica, objetos UIElement, IDocumentPaginatorSourcee elementos Visual. Além disso, ISerializerFactory fornece os mesmos métodos e eventos síncronos e assíncronos usados por serializadores vinculados. Como documentos grandes podem levar tempo para serem produzidos, operações assíncronas são recomendadas para manter a interação responsiva do usuário e oferecer uma opção "Cancelar" se ocorrer algum problema com o armazenamento de dados.

  3. Depois que o serializador de plug-in é criado, um script de instalação é implementado para distribuir e instalar (e desinstalar) o plug-in (veja acima, "Instalando serializadores de plug-in").

Ver também