Esta página foi útil?
Seus comentários sobre este conteúdo são importantes. Queremos saber sua opinião.
Comentários adicionais?
1500 caracteres restantes
Biblioteca MSDN
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
Informações
O tópico solicitado está sendo mostrado abaixo. No entanto, este tópico não está incluído nesta biblioteca.

Serialização e armazenamento do 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 seções a seguir.

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 serializador "gravar" método para salvar o documento, enquanto a desserialização de uma "read" método acessa o armazenamento de dados e recria a instância original na 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 para um arquivo de disco, banco de dados ou serviço da 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.

ms745778.collapse_all(pt-br,VS.110).gifRecursos dos serializadores de documento do .NET Framework 3.0

  • Acesso direto aos documentos de alto nível objetos (árvore lógica e visuais) permite um armazenamento eficiente de conteúdo paginado, elementos 2D/3D, imagens, mídia, hiperlinks, anotações e outros conteúdos de apoio.

  • Operação síncrona e assíncrona.

  • Suporte para plug-in serializadores com recursos avançados:

    • Acesso a todo o sistema para utilização por todos as aplicações feitas no .NET Framework.

    • O plug-in de descoberta para aplicação simples.

    • Simples implantação, instalação e atualização para plugins personalizados de terceiros.

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

ms745778.collapse_all(pt-br,VS.110).gifCaminho de Impressão XPS

O Microsoft .NET FrameworkXPS caminho de impressão também oferece um amplo mecanismo para escrever documentos por meio de saída de impressão.  XPSserve como formato de arquivo de documento e é o formato de spool de impressão nativo para Windows Vista. XPSdocumentos podem ser enviados diretamente para XPS-impressoras compatíveis sem a necessidade de conversão em um formato intermediário. Consulte Visão geral da 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.

ms745778.collapse_all(pt-br,VS.110).gifUsando 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 SerializerProvider método 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.


// 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;
}


ms745778.collapse_all(pt-br,VS.110).gifInstalando plug-ins serializadores

O SerializerProvider classe fornece a interface de aplicativo de nível superior para acesso e detecção de plug-in do serializador. SerializerProvider Localiza e fornece uma lista dos serializadores que estão instalados e acessíveis no sistema de aplicativo. 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.

ms745778.collapse_all(pt-br,VS.110).gifCriando 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 é totalmente testado, um ISerializerFactory interface é adicionada ao criar um plug-in. O ISerializerFactory interface permite acesso total 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. Uma vez que documentos grandes podem levar tempo para saída, 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 é criado, um script de instalação é implementado para distribuir e instalar (e desinstalar) o plug-in (veja acima, "Instalar o plug-in serializadores").

Contribuições da comunidade

Mostrar:
© 2015 Microsoft