Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original
1 de 1 pessoas classificaram isso como útil - Avalie este tópico

Serialização e Armazenamento de Documento

Microsoft. NET Framework fornece um ambiente poderoso para criar e exibir documentos de alta qualidade. Recursos avançados de suporte a documentos fixos e de fluxo-documentos, controles de visualização avançadas, combinadas com poderosos 2D e capacidades gráficas 3D tomar. NET Framework para um novo nível de qualidade e experiência do usuário. Ser capaz de gerir de forma flexível uma representação em memória de um documento é uma característica fundamental do. NET Framework, e ser capaz de salvar de forma eficiente e carregar documentos de um repositório de dados é uma necessidade de quase todos os aplicativos. O processo de conversão de um documento a partir de uma representação interna em memória para um 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.

Idealmente, o processo de serialização e desserialização de um documento a partir e depois de volta para a memória é transparente para a aplicação. 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 que os dados são armazenados em geral 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 oferecem várias opções de serialização que permitem ao usuário salvar documentos em mídia diferente ou para 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 alternativamente a um formato de terceiros. Para a aplicação, a serialização define uma interface que isola os detalhes do meio de armazenamento no âmbito 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.

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 utilização de todo o sistema. Serializadores via ligação também pode ser implementado para ambientes de confiança parcial, como aplicativos de navegador XAML (XBAPs), onde serializadores plug-in 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. Ambos os serializadores plug-in e serializers vinculados operar através de métodos públicos e eventos idênticos, que tornam mais fácil de usar um ou ambos os tipos de serializadores no mesmo aplicativo.

Plug-in desenvolvedores de aplicativos ajuda serializers fornecendo extensibilidade para novos projetos de armazenamento e formatos de arquivos sem a necessidade de código diretamente para cada formato de potencial em tempo de 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-in 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 plug-in serializador padrão para XPS é fornecido com. 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:

  1. 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.

  2. 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.

  3. 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).

Isso foi útil para você?
(1500 caracteres restantes)
Agradecemos os seus comentários

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft. Todos os direitos reservados.