Demonstra Passo a passo: Tipos de incorporação de Assemblies gerenciados (C# e Visual Basic)

Artigo
08/01/2011

Se você incorporar informações de tipo de um assembly gerenciado fortes, é possível acoplar livremente o tipos em um aplicativo para atingir a independência de versão. Ou seja, seu programa pode ser escrito para usar os tipos de várias versões de uma biblioteca gerenciada sem precisar ser recompilado para cada versão.

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

Informações de tipo podem ser incorporadas a partir de um conjunto que possui as seguintes características:

O assembly que expõe a pelo menos uma interface pública.
As interfaces incorporadas são anotadas com um ComImport atributo e um Guid atributo (e um GUID exclusivo).
O assembly é anotado com o ImportedFromTypeLib atributo ou o PrimaryInteropAssembly atributo e um nível de conjunto Guid atributo. (Por padrão, os modelos de projeto de Visual Basic e C# Visual incluem um nível de conjunto Guid atributo.)

Após você ter especificado as interfaces públicas que podem ser incorporadas, você pode criar classes de tempo de execução que implementam essas interfaces. Um programa cliente pode incorporar as informações de tipo para essas interfaces no tempo de design consultando o assembly que contém a configuração e as interfaces públicas de Embed Interop Types a propriedade de uma referência ao True. Isso é equivalente a usando o compilador de linha de comando e referenciar o assembly usando o /link opção de compilador. O programa cliente pode ser carregados instâncias de objetos de runtime digitadas como essas interfaces. Se você criar uma nova versão do seu assembly de nome forte o tempo de execução, o programa cliente não tem que ser recompilados com o assembly em tempo de execução atualizados. Em vez disso, o programa cliente continua a usar qualquer versão do assembly em tempo de execução está disponível para ele, usando as informações de tipo incorporados para interfaces públicas.

Como a principal função do tipo de incorporação é oferecer suporte a incorporação de informações de tipo de assemblies de interoperabilidade COM, as seguintes limitações se aplicam quando você incorpora informações de tipo em uma solução totalmente gerenciada:

Somente os atributos específicos ao COM interop são incorporados. outros atributos são ignorados.
Se um tipo usa parâmetros genéricos e o tipo do parâmetro genérico é um tipo de incorporado, esse tipo não pode ser usado em um limite de assembly. Cruzando um limite de conjunto exemplos de chamar um método de outro assembly ou derivar um tipo de um tipo definido em outro assembly.
Constantes não são incorporados.
O System.Collections.Generic.Dictionary<TKey, TValue> classe não oferece suporte a um tipo de incorporado como uma chave. Você pode implementar seu próprio tipo de dicionário para oferecer suporte a um tipo de incorporado como uma chave.

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

Crie um assembly de nome forte tem uma interface pública que contém informações de tipo que podem ser incorporadas.
Crie um assembly de nome forte runtime que implementa essa interface pública.
Crie um programa cliente que incorpora as informações de tipo da interface pública e cria uma instância da classe do assembly em tempo de execução.
Modificar e recompilar o assembly em tempo de execução.
Execute o programa de cliente para ver que a nova versão do assembly em tempo de execução está sendo usada sem ter que recompilar o programa 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 do Visual Studio.

Criando uma Interface.

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

Em Visual Studio, no menu File, aponte para New e então clique em Project.
No Novo projeto na caixa de Tipos de projeto painel, certifique-se de que Windows está selecionada. Selecione Biblioteca de classe na modelos de painel. No nome , digite TypeEquivalenceInterfacee em seguida, clique em OK. O novo projeto é criado.
Em Solution Explorer, o botão direito do mouse no arquivo Class1. vb ou Class1. cs e clique em Renomear. Renomeie o arquivo para ISampleInterface.vb ou ISampleInterface.cs e pressione ENTER. Renomear o arquivo também renomear a classe ISampleInterface. Essa classe será representam a interface pública para a classe.
Clique com o botão direito no projeto TypeEquivalenceInterface e clique em Propriedades. Clique o compilar guia Visual Basic ou Build guia Visual C#. Defina o caminho de saída para um local válido no computador de desenvolvimento, como C:\TypeEquivalenceSample. Este local também será usado em uma etapa posterior neste passo a passo.
Enquanto ainda editando as propriedades do projeto, clique na assinatura guia. Selecione o Sign the assembly opção. No Choose a strong name key file , clique em < New... >. No nome do arquivo de chave , digite key.snk. Limpar o Protect my key file com uma senha caixa de seleção. Clique em OK.

Abra o arquivo ISampleInterface.vb ou ISampleInterface.cs. Adicione o seguinte código ao arquivo de classe ISampleInterface para criar a interface 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; }


...


    }
}

Sobre o Ferramentas menu, clique em Criar Guid. No Criar GUID caixa de diálogo, clique em Formato do registro e, em seguida, clique em Copy. Clique em Sair.
No Guid de atributo, exclua o GUID de exemplo e cole o GUID que você copiou da Criar GUID caixa de diálogo. Remova as chaves ({}) do GUID copiado.
Em Visual Basicdiante do projeto menu, clique em Mostrar todos os arquivos. Ignorar esta etapa, se você estiver usando Visual C#.
Em Solution Explorer, expanda o My Project pasta se você estiver usando Visual Basic. Expanda o Propriedades pasta se você estiver usando Visual C#. Clique duas vezes no arquivo AssemblyInfo. vb ou AssemblyInfo. cs. Adicione o seguinte atributo ao arquivo.
```
<Assembly: ImportedFromTypeLib("")> 
```
```
[assembly: ImportedFromTypeLib("")]
```
Salve o arquivo.
Salve o projeto.
Clique com o botão direito no projeto TypeEquivalenceInterface e clique em Build. O arquivo. dll da biblioteca de classe é compilado e salva o caminho de saída de compilação especificada (por exemplo, C:\TypeEquivalenceSample).

Criando uma classe de tempo de execução

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

Em Visual Studio, no menu File, aponte para New e então clique em Project.
No Novo projeto na caixa de Tipos de projeto painel, certifique-se de que Windows está selecionada. Selecione Biblioteca de classe na modelos de painel. No nome , digite TypeEquivalenceRuntimee em seguida, clique em OK. O novo projeto é criado.
Em Solution Explorer, o botão direito do mouse no arquivo Class1. vb ou Class1. cs e clique em Renomear. Renomeie o arquivo para SampleClass.vb ou SampleClass.cs e pressione ENTER. Também é renomear o arquivo renomeia a classe SampleClass. Essa classe irá implementar a ISampleInterface interface.
Clique com o botão direito no projeto TypeEquivalenceRuntime e clique em Propriedades. Clique o compilar guia Visual Basic ou Build guia Visual C#. Definir o caminho de saída para o mesmo local usado no projeto TypeEquivalenceInterface, por exemplo, C:\TypeEquivalenceSample.
Enquanto ainda editando as propriedades do projeto, clique na assinatura guia. Selecione o Sign the assembly opção. No Choose a strong name key file , clique em < New... >. No nome do arquivo de chave , digite key.snk. Limpar o Protect my key file com uma senha caixa de seleção. Clique em OK.
Clique com o botão direito no projeto TypeEquivalenceRuntime e clique em Adicionar referência de. Clique o Procurar guia e navegue até a pasta de caminho de saída. Selecione o arquivo TypeEquivalenceInterface.dll e clique em OK.
Em Visual Basicdiante do projeto menu, clique em Mostrar todos os arquivos. Ignorar esta etapa, se você estiver usando Visual C#.
Em Solution Explorer, expanda o referências pasta. Selecione a referência de TypeEquivalenceInterface. Na janela Propriedades para a referência de TypeEquivalenceInterface, defina a Versão específica propriedade para False.

Adicione o seguinte código ao arquivo de classe SampleClass para criar a classe 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();
        }


...


    }
}

Salve o projeto.
Clique com o botão direito no projeto TypeEquivalenceRuntime e clique em Build. O arquivo. dll da biblioteca de classe é compilado e salva o caminho de saída de compilação especificada (por exemplo, C:\TypeEquivalenceSample).

Criando um projeto de cliente

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

Em Visual Studio, no menu File, aponte para New e então clique em Project.
No Novo projeto na caixa de Tipos de projeto painel, certifique-se de que Windows está selecionada. Selecione Aplicativo de Console na modelos de painel. No nome , digite TypeEquivalenceCliente em seguida, clique em OK. O novo projeto é criado.
Clique com o botão direito no projeto TypeEquivalenceClient e clique em Propriedades. Clique o compilar guia Visual Basic ou Build guia Visual C#. Definir o caminho de saída para o mesmo local usado no projeto TypeEquivalenceInterface, por exemplo, C:\TypeEquivalenceSample.
Clique com o botão direito no projeto TypeEquivalenceClient e clique em Adicionar referência de. Clique o Procurar guia e navegue até a pasta de caminho de saída. Selecione o arquivo de TypeEquivalenceInterface.dll (não o TypeEquivalenceRuntime.dll) e clique em OK.
Em Visual Basicdiante do projeto menu, clique em Mostrar todos os arquivos. Ignorar esta etapa, se você estiver usando Visual C#.
Em Solution Explorer, expanda o referências pasta. Selecione a referência de TypeEquivalenceInterface. Na janela Propriedades para a referência de TypeEquivalenceInterface, defina a Incorporar tipos de interoperabilidade propriedade para True.

Adicione o seguinte código para o arquivo de Module1. vb ou Program. cs para criar o programa 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.

Modificação da Interface

Para modificar a interface

Em Visual Studiodiante do arquivo , aponte para Abrire, em seguida, clique em Project/Solution.
No Abrir projeto caixa de diálogo, clique com o botão direito no projeto TypeEquivalenceInterface e clique em Propriedades. Clique na guia Application. Clique o Informações de Assembly botão. Alterar o Versão do Assembly e Versão do arquivo valores para 2.0.0.0.
Abra o arquivo ISampleInterface.vb ou ISampleInterface.cs. Adicione a seguinte linha de código para a interface ISampleInterface.
```
Function GetDate() As Date
```
```
DateTime GetDate();
```
Salve o arquivo.
Salve o projeto.
Clique com o botão direito no projeto TypeEquivalenceInterface e clique em Build. Uma nova versão do arquivo. dll da biblioteca de classe é compilada e salvo no caminho de saída de compilação especificada (por exemplo, C:\TypeEquivalenceSample).

Modificar a classe Runtime

Para modificar a classe runtime

Em Visual Studiodiante do arquivo , aponte para Abrire, em seguida, clique em Project/Solution.
No Abrir projeto caixa de diálogo, clique com o botão direito no projeto TypeEquivalenceRuntime e clique em Propriedades. Clique na guia Application. Clique o Informações de Assembly botão. Alterar o Versão do Assembly e Versão do arquivo valores para 2.0.0.0.

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

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

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

Salve o arquivo.

Salve o projeto.
Clique com o botão direito no projeto TypeEquivalenceRuntime e clique em Build. Uma versão atualizada do arquivo. dll da biblioteca de classe é compilada e salvo no caminho de saída de compilação especificado anteriormente (por exemplo, C:\TypeEquivalenceSample).
No Windows Explorer, abra a pasta de caminho de saída (por exemplo, C:\TypeEquivalenceSample). Clique duas vezes o TypeEquivalenceClient.exe para executar o programa. O programa irá refletir a nova versão do assembly TypeEquivalenceRuntime sem ter que foram recompilados.

Consulte também

Compartilhar via