Share 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 oferecem suporte a documentos fixos e documentos de fluxo, controles de exibiçã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 com flexibilidade uma representação na memória de um documento é um recurso fundamental do .NET Framework, e ser capaz de salvar e carregar documentos de um armazenamento de dados com eficiência é uma necessidade de quase todos os aplicativos. O processo de conversão de um documento de uma representação na memória interna em um armazenamento de dados externo é chamado de serialização. O processo inverso de ler um armazenamento de dados e recriar a instância original na memória é chamado desserialização.

Sobre a serialização de documento

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 em memória. O formato específico que os dados são armazenados, geralmente, não é uma preocupação do aplicativo, desde que o processo de serializar e desserializar recrie o documento em sua forma original.

Geralmente, os aplicativos fornecem várias opções de serialização que permitem ao usuário salvar 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 de 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 de encapsular detalhes de armazenamento, as APIs do .NET Framework System.Windows.Documents.Serialization fornecem vários outros recursos importantes.

Recursos dos serializadores de documento do .NET Framework 3.0

  • O acesso direto aos objetos de documento de alto nível (á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ções síncronas e assíncronas.

  • Suporte para serializadores de plug-ins com recursos aprimorados:

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

    • Descoberta de plug-in de aplicativo simples.

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

    • Suporte à interface do usuário para opções e configuraçõ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 gravar documentos por meio 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 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 System.Windows.Documents.Serialization APIs fornecem suporte para serializadores de plug-in e serializadores vinculados que são instalados separadamente do aplicativo, vinculam em tempo de execução e são acessados usando o SerializerProvider mecanismo de descoberta. 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 se baseiam em uma implementação derivada da SerializerWriter classe, são compilados e vinculados diretamente ao aplicativo. Os serializadores de plug-in e serializadores vinculados operam por métodos públicos idênticos e eventos, o que torna mais fácil 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 para novos projetos de armazenamento e formatos de arquivo sem a necessidade de código diretamente para cada formato em potencial no momento de build. Os serializadores de plug-in também beneficiam os desenvolvedores de terceiros, fornecendo um meio padronizado para implantar, instalar e atualizar plug-ins acessíveis pelo 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 SerializerProvider classe enumera um SerializerDescriptor objeto para cada plug-in instalado no sistema. A IsLoadable propriedade 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 enumerado. Depois que o usuário seleciona um formato de saída, o método é usado para criar um SerializerWriter para o CreateSerializerWriter formato específico. O SerializerWriter.Write método pode então ser chamado para gerar a saída do fluxo de documentos para o armazenamento de dados.

O exemplo a seguir ilustra um aplicativo que usa o SerializerProvider método em uma propriedade "PlugInFileFilter". PlugInFileFilter enumera os plug-ins instalados e cria uma cadeia de caracteres de filtro com as opções de arquivo disponíveis para um SaveFileDialogarquivo .

// ------------------------ 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 CreateSerializerWriter uso do método 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 SerializerProvider classe 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 nas configurações do Registro. Os serializadores de plug-in podem ser adicionados ao Registro usando o método ou, se o .NET Framework ainda não estiver instalado, o RegisterSerializer script de instalação do plug-in pode definir diretamente os próprios valores do Registro. O UnregisterSerializer método 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 plug-in

Os serializadores de plug-in e os serializadores vinculados usam os mesmos eventos e métodos 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. Implementar e depurar o serializador primeiramente como um serializador vinculado. Criar, inicialmente, o serializador compilado e o vinculado diretamente em um aplicativo de teste fornece acesso completo a pontos de interrupção e outros serviços de depuração úteis para teste.

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

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

Confira também