Passo a passo: Incorporação de tipos a partir de Assemblies gerenciados (C# e Visual Basic)

Artigo
02/25/2013

Se você inserir informações de tipo de um assembly de nome forte gerenciado, você pode pouco acoplar-se em um aplicativo obter a independência de versão.Isto é, o programa pode ser escrito para os tipos de uso de várias versões de uma biblioteca gerenciado sem precisar ser recompilado para cada versão.

A incorporação de tipo é freqüentemente usada com interoperabilidade COM, como um aplicativo que usa objetos de automação do Microsoft Office.Inserir informações de tipo permite a mesma versão de um programa para trabalhar com versões diferentes do Microsoft Office em computadores diferentes.Em o entanto, você também pode usar a incorporação de tipo com uma solução totalmente gerenciado.

Informações de tipo pode ser incorporada de um assembly que tenha as seguintes características:

O assembly expostos pelo menos uma interface pública.
Interfaces são inseridos anotadas com um atributo de ComImport e um atributo de Guid e exclusivo (GUID).
O assembly é anotado com o atributo de ImportedFromTypeLib ou o atributo de PrimaryInteropAssembly , e um atributo de Guid de nível de montagem.(Por padrão, Visual Basic e modelos de projeto visual C# incluem um atributo de Guid de nível de montagem.)

Depois que você especificou as interfaces públicas que podem ser inseridas, você pode criar classes em tempo de execução que implementam essas interfaces.Um programa de cliente pode então inserir informações de tipo para essas interfaces em tempo de design referência do assembly que contém interfaces públicas e defina a propriedade de Embed Interop Types de referência a True.Isso é equivalente a usar o compilador de linha de comando e a referenciar o assembly usando a opção de compilador /link .O programa de cliente pode então carregar instâncias de seus objetos de tempo de execução tipados como essas interfaces.Se você criar uma nova versão do assembly de nome forte em tempo de execução, o programa de cliente não tem que ser recompilado com o módulo atualizado em tempo de execução.Em vez de isso, o programa continua de cliente para usar qualquer versão do conjunto de tempo de execução está disponível a ela, usando as informações inserida de tipo para as interfaces públicas.

Porque papel primário para inserir de tipo é oferecer suporte a incorporação de informações do tipo dos assemblies de interoperabilidade COM, as seguintes limitações se aplicam quando você inserir informações tipo em uma solução totalmente gerenciado:

Somente os atributos específicos para interoperabilidade COM são inseridos; outros atributos são ignorados.
Se um tipo usa parâmetros genéricos e o tipo de parâmetro genérico é um tipo inserido, esse tipo não pode ser usado por um limite do assembly.Exemplos de cruzar o limite do assembly incluem chamar um método de outro assembly ou derivar de um tipo de um tipo definido em outro assembly.
Constantes não são inseridas.
A classe de System.Collections.Generic.Dictionary<TKey, TValue> não suporta um tipo inserido como uma chave.Você pode implementar seu próprio tipo de dicionário para oferecer suporte a um tipo inserido como uma chave.

Em essa explicação passo a passo, você irá fazer o seguinte:

Criar um assembly de nome forte que tenha uma interface pública que contém informações de tipo que pode ser incorporada.
Criar um assembly de nome forte em tempo de execução que implementa a interface pública.
Crie um programa de cliente que incorpora as informações de tipo de interface pública e crie uma instância da classe do conjunto de tempo de execução.
Modifique e recriar o conjunto de tempo de execução.
Executar o programa de cliente para ver que a nova versão do conjunto de tempo de execução está sendo usada sem ter que recompilar o programa de cliente.

Observação
Seu computador pode mostrar nomes ou locais diferentes para alguns dos elementos da interface do usuário do Visual Studio nas instruções a seguir. A edição do Visual Studio que você possui e as configurações que você usa determinam esses elementos. Para obter mais informações, consulte Configurações de Visual Studio.

Criando uma interface

Para criar o projeto de equivalência da interface de tipo

Em Visual Studio, no menu File, aponte para New e então clique em Project.
Em a caixa de diálogo de Novo Projeto , no painel de tipos de projeto , certifique-se que está selecionado Janelas .Biblioteca de Classes Selecione no painel de Modelos .Em a caixa de Nome , o tipo TypeEquivalenceInterface, e clique em OK.o novo projeto é criado.
Em Gerenciador de Soluções, clique com o botão direito do mouse no arquivo de Class1.vb ou de Class1.cs e clique Renomear.Renomeie o arquivo para ISampleInterface.vb ou a ISampleInterface.cs e pressione ENTER.Renomeando o arquivo também renomeará a classe ISampleInterface.Essa classe irá representar a interface pública para a classe.
Clique com o botão direito do mouse no projeto de TypeEquivalenceInterface e clique em Propriedades.Clique na guia de Compilar em Visual Basic ou a guia de Compilar em Visual C#.Defina o caminho de saída para um local válido no seu computador de desenvolvimento, como C:\TypeEquivalenceSample.Esse local também será usado em uma etapa posterior em essa explicação passo a passo.
Enquanto ainda editar as propriedades do projeto, clique na guia de Assinando .Selecione a opção de Assine o assembly .Em a lista de Escolha um arquivo de chave de nome forte , **<New...>**clique em.Em a caixa de feche o nome de arquivo , digite key.snk.Desmarque a caixa de seleção de Proteger meu arquivo de chave com uma senha .Clique em OK.

Abra o arquivo de ISampleInterface.vb ou de ISampleInterface.cs.Adicione o seguinte código ao arquivo de classe ISampleInterface para criar a interface de ISampleInterface.

Imports System.Runtime.InteropServices

<ComImport()>
<Guid("8DA56996-A151-4136-B474-32784559F6DF")>
Public Interface ISampleInterface
    Sub GetUserInput()
    ReadOnly Property UserInput As String


...


End Interface

using System;
using System.Runtime.InteropServices;

namespace TypeEquivalenceInterface
{
    [ComImport]
    [Guid("8DA56996-A151-4136-B474-32784559F6DF")]
    public interface ISampleInterface
    {
        void GetUserInput();
        string UserInput { get; }


...


    }
}

Em o menu de Ferramentas , clique Criar GUID.Em a caixa de diálogo de Criar GUID , clique em Formato do Registro e clique em Copiar.Clique Sair.
Em o atributo de Guid , exclua o exemplo GUID e cole-o no GUID que você copiou da caixa de diálogo de Criar GUID .Remova as chaves ({}) de GUID copiado.
Em Visual Basic, no menu de Projeto , clique Mostrar todos os arquivos.Ignore esta etapa se você estiver usando Visual C#.
Em Gerenciador de Soluções, expanda a pasta de meu projeto se você estiver usando Visual Basic.Expanda a pasta de Propriedades se você estiver usando Visual C#.Clique duas vezes no arquivo AssemblyInfo.cs ou AssemblyInfo.vb.Adicione o seguinte atributo ao arquivo.
```
<Assembly: ImportedFromTypeLib("")> 
```
```
[assembly: ImportedFromTypeLib("")]
```
Salve o arquivo.
Salvar o projeto.
Clique com o botão direito do mouse no projeto de TypeEquivalenceInterface e clique em Compilar.O arquivo .dll de biblioteca de classes é compilado e salvo ao caminho especificado de saída de compilação (por exemplo, C:\TypeEquivalenceSample).

Criando uma classe de tempo de execução

Para criar o projeto de equivalência de tempo de execução de tipo

Em Visual Studio, no menu File, aponte para New e então clique em Project.
Em a caixa de diálogo de Novo Projeto , no painel de tipos de projeto , certifique-se que está selecionado Janelas .Biblioteca de Classes Selecione no painel de Modelos .Em a caixa de Nome , o tipo TypeEquivalenceRuntime, e clique em OK.o novo projeto é criado.
Em Gerenciador de Soluções, clique com o botão direito do mouse no arquivo de Class1.vb ou de Class1.cs e clique Renomear.Renomeie o arquivo para SampleClass.vb ou a SampleClass.cs e pressione ENTER.Renomeando o arquivo também renomeia a classe SampleClass.Essa classe irá implementar a interface de ISampleInterface .
Clique com o botão direito do mouse no projeto de TypeEquivalenceRuntime e clique em Propriedades.Clique na guia de Compilar em Visual Basic ou a guia de Compilar em Visual C#.Defina o caminho de saída para o mesmo local que você usou no projeto de TypeEquivalenceInterface, por exemplo, C:\TypeEquivalenceSample.
Enquanto ainda editar as propriedades do projeto, clique na guia de Assinando .Selecione a opção de Assine o assembly .Em a lista de Escolha um arquivo de chave de nome forte , **<New...>**clique em.Em a caixa de feche o nome de arquivo , digite key.snk.Desmarque a caixa de seleção de Proteger meu arquivo de chave com uma senha .Clique em OK.
Clique com o botão direito do mouse no projeto de TypeEquivalenceRuntime e clique em Adicionar Referência.Clique na guia de Procurar e procure a pasta do caminho de saída.Selecione o arquivo de TypeEquivalenceInterface.dll e clique OK.
Em Visual Basic, no menu de Projeto , clique Mostrar todos os arquivos.Ignore esta etapa se você estiver usando Visual C#.
Em Gerenciador de Soluções, expanda a pasta de Referências .Selecione a referência de TypeEquivalenceInterface.Em a janela propriedades para a referência de TypeEquivalenceInterface, defina a propriedade de Versão Específica a False.

Adicione o seguinte código ao arquivo de classe SampleClass para criar a classe de SampleClass.

Imports TypeEquivalenceInterface

Public Class SampleClass
    Implements ISampleInterface

    Private p_UserInput As String
    Public ReadOnly Property UserInput() As String Implements ISampleInterface.UserInput
        Get
            Return p_UserInput
        End Get
    End Property

    Public Sub GetUserInput() Implements ISampleInterface.GetUserInput
        Console.WriteLine("Please enter a value:")
        p_UserInput = Console.ReadLine()
    End Sub


...


End Class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TypeEquivalenceInterface;

namespace TypeEquivalenceRuntime
{
    public class SampleClass : ISampleInterface
    {
        private string p_UserInput;
        public string UserInput { get { return p_UserInput; } }

        public void GetUserInput()
        {
            Console.WriteLine("Please enter a value:");
            p_UserInput = Console.ReadLine();
        }


...


    }
}

Salvar o projeto.
Clique com o botão direito do mouse no projeto de TypeEquivalenceRuntime e clique em Compilar.O arquivo .dll de biblioteca de classes é compilado e salvo ao caminho especificado de saída de compilação (por exemplo, C:\TypeEquivalenceSample).

Criando um projeto do cliente

Para criar o projeto de equivalência do cliente de tipo

Em Visual Studio, no menu File, aponte para New e então clique em Project.
Em a caixa de diálogo de Novo Projeto , no painel de tipos de projeto , certifique-se que está selecionado Janelas .Aplicativo de Console Selecione no painel de Modelos .Em a caixa de Nome , o tipo TypeEquivalenceClient, e clique em OK.o novo projeto é criado.
Clique com o botão direito do mouse no projeto de TypeEquivalenceClient e clique em Propriedades.Clique na guia de Compilar em Visual Basic ou a guia de Compilar em Visual C#.Defina o caminho de saída para o mesmo local que você usou no projeto de TypeEquivalenceInterface, por exemplo, C:\TypeEquivalenceSample.
Clique com o botão direito do mouse no projeto de TypeEquivalenceClient e clique em Adicionar Referência.Clique na guia de Procurar e procure a pasta do caminho de saída.Selecione o arquivo de TypeEquivalenceInterface.dll (não o TypeEquivalenceRuntime.dll) e clique OK.
Em Visual Basic, no menu de Projeto , clique Mostrar todos os arquivos.Ignore esta etapa se você estiver usando Visual C#.
Em Gerenciador de Soluções, expanda a pasta de Referências .Selecione a referência de TypeEquivalenceInterface.Em a janela propriedades para a referência de TypeEquivalenceInterface, defina a propriedade de Inserir Tipos Interop a True.

Adicione o seguinte código ao arquivo Module1.vb ou de Module.vb para criar o programa de cliente.

Imports TypeEquivalenceInterface
Imports System.Reflection

Module Module1

    Sub Main()
        Dim sampleAssembly = Assembly.Load("TypeEquivalenceRuntime")
        Dim sampleClass As ISampleInterface = CType( _
            sampleAssembly.CreateInstance("TypeEquivalenceRuntime.SampleClass"), ISampleInterface)
        sampleClass.GetUserInput()
        Console.WriteLine(sampleClass.UserInput)
        Console.WriteLine(sampleAssembly.GetName().Version)
        Console.ReadLine()
    End Sub

End Module

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TypeEquivalenceInterface;
using System.Reflection;

namespace TypeEquivalenceClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly sampleAssembly = Assembly.Load("TypeEquivalenceRuntime");
            ISampleInterface sampleClass = 
                (ISampleInterface)sampleAssembly.CreateInstance("TypeEquivalenceRuntime.SampleClass");
            sampleClass.GetUserInput();
            Console.WriteLine(sampleClass.UserInput);
            Console.WriteLine(sampleAssembly.GetName().Version.ToString());
            Console.ReadLine();
        }
    }
}

Pressione CTRL+F5 para compilar e executar o programa.

Alterando a interface

Para alterar o interface

Em Visual Studio, no menu de Arquivo , aponte para Abrir, e clique em projeto/solução.
Em a caixa de diálogo de Abrir Projeto , clique com o botão direito do mouse no projeto de TypeEquivalenceInterface, clique em Propriedades.Clique na guia Application.Clique no botão de Informações de assembly .Alterar os valores de Versão do Assembly e de Versão do Arquivo a 2.0.0.0.
Abra o arquivo de ISampleInterface.vb ou de ISampleInterface.cs.Adicione a seguinte linha de código para a interface de ISampleInterface.
```
Function GetDate() As Date
```
```
DateTime GetDate();
```
Salve o arquivo.
Salvar o projeto.
Clique com o botão direito do mouse no projeto de TypeEquivalenceInterface e clique em Compilar.Uma nova versão do arquivo .dll biblioteca de classe é criada e salva no caminho especificado de saída de compilação (por exemplo, C:\TypeEquivalenceSample).

Alterando a classe de tempo de execução

Para alterar a classe de tempo de execução

Em Visual Studio, no menu de Arquivo , aponte para Abrir, e clique em projeto/solução.
Em a caixa de diálogo de Abrir Projeto , clique com o botão direito do mouse no projeto de TypeEquivalenceRuntime e clique em Propriedades.Clique na guia Application.Clique no botão de Informações de assembly .Alterar os valores de Versão do Assembly e de Versão do Arquivo a 2.0.0.0.

Abra o arquivo de SampleClass.vb ou de SampleClass.cs.Adicione as seguintes linhas de código para a classe de SampleClass.

Public Function GetDate() As DateTime Implements ISampleInterface.GetDate
    Return Now
End Function

public DateTime GetDate()
{
    return DateTime.Now;
}

Salve o arquivo.

Salvar o projeto.
Clique com o botão direito do mouse no projeto de TypeEquivalenceRuntime e clique em Compilar.Uma versão atualizada do arquivo .dll biblioteca de classe é criada e salva no caminho especificado previamente de saída de compilação (por exemplo, C:\TypeEquivalenceSample).
Em o Arquivo Explorer, abra a pasta do caminho de saída (por exemplo, C:\TypeEquivalenceSample).Clique duas vezes no TypeEquivalenceClient.exe para executar o programa.O programa refletirá a nova versão do conjunto de TypeEquivalenceRuntime sem ter sido recompilado.

Consulte também

Partilhar via