Compartilhar via

Serialização e armazenamento de documentos

O Microsoft .NET Framework fornece um ambiente poderoso para criar e exibir documentos de alta qualidade. Recursos aprimorados que dão suporte a documentos fixos e documentos de fluxo, controles de exibição avançados, combinados com recursos gráficos 2D e 3D poderosos 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 com eficiência 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 em um armazenamento de dados externo é chamado de 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 da e de volta para a memória é transparente para o aplicativo. 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 no qual 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 ao formulário original.

Os aplicativos geralmente oferecem várias opções de serialização que permitem ao usuário salvar documentos em diferentes meios ou formatos. 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, serializadores diferentes podem armazenar o documento em formatos diferentes, como em HTML, RTF, XML, XPS ou, como alternativa, 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 de encapsular detalhes de armazenamento, as APIs do .NET Framework System.Windows.Documents.Serialization fornecem vários outros recursos importantes.

Recursos de 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 funcionalidades aprimoradas:

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

    • Descoberta de plug-in de aplicativo simples.

    • 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 por meio da saída de impressão. O XPS serve como um formato de arquivo de documento e é o formato de spool de impressão nativo do Windows Vista. Documentos XPS podem ser enviados diretamente para impressoras compatíveis com XPS sem a necessidade de conversão em um formato intermediário. Consulte a Visão geral sobre impressão para obter informações adicionais sobre as opções de saída de caminho de impressão e recursos.

Plug-ins serializadores

As APIs System.Windows.Documents.Serialization dão suporte para serializadores de plug-ins e serializadores vinculados que são instalados separadamente do aplicativo, associados no tempo de execução e acessados usando o mecanismo de descoberta SerializerProvider. Os serializadores de plug-in oferecem benefícios aprimorados para facilitar a implantação e o uso em todo o sistema. Serializadores vinculados também podem ser implementados para ambientes de confiança parcial, como XBAPs (aplicativos de navegador XAML), em que os serializadores de plug-in não são acessíveis. Serializadores vinculados, que se baseiam em uma implementação derivada da classe SerializerWriter, são compilados e vinculados diretamente ao aplicativo. Tanto serializadores plug-in quanto serializadores vinculados operam por meio de métodos públicos e eventos idênticos, o que facilita o uso de ambos os tipos de serializadores no mesmo aplicativo.

Os serializadores de plug-in ajudam os desenvolvedores de aplicativos fornecendo extensibilidade para novos designs de armazenamento e formatos de arquivo sem precisar 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 do 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 está 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 ser chamado para enviar 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 lista os plug-ins instalados e cria um 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;
    }
}

Depois que um nome de arquivo de saída tiver sido 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 plug-in

A classe SerializerProvider fornece a interface de aplicativo de nível superior para descoberta e acesso do serializador de plug-in. SerializerProvider localiza e fornece ao aplicativo uma lista dos serializadores instalados e acessíveis no sistema. As especificidades dos serializadores instalados são definidas por meio 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 da mesma forma por um script de desinstalação.

Criando um serializador de plug-in

Tanto serializadores de plug-in quanto 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. Normalmente, há três etapas básicas seguidas para criar um serializador de plug-in:

  1. Implementar e depurar o serializador primeiramente como um serializador vinculado. Inicialmente, compilar e vincular diretamente o serializador 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 incluem a árvore lógica, UIElement objetos, 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 a saída, as operações assíncronas são recomendadas para manter a interação do usuário responsiva 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 (consulte acima, "Instalando serializadores de plug-in").

Consulte também

  • Last updated on