Artigo: 897297 - Última revisão: quarta-feira, 14 de Novembro de 2007 - Revisão: 2.7

A consumir assemblagens localizadas numa pasta diferente da pasta de base de aplicação em Visual Basic .NET ou do Visual Basic 2005

Vista lado a ladoClique aqui para exibir o artigo traduzido e o artigo original em inglês, lado a lado.
Tradução automáticaVer isenção de responsabilidades para tradução automática
Ver produtos para os quais este artigo se aplica.
Dica do SistemaEste artigo aplica-se a um sistema operativo diferente do que está a utilizar. Foi desactivado o conteúdo do artigo, que pode não ser relevante para si.

Nesta página

Expandir tudo | Reduzir tudo

INTRODUÇÃO

Este artigo explica como consumir assemblagens localizadas numa pasta que é diferente da pasta de base da aplicação numa solução Microsoft Visual Basic .NET ou o Microsoft Visual Basic 2005.
Voltar ao topo

Mais Informação

Quando executa uma aplicação do Visual Basic .NET ou Visual Basic 2005, o common language runtime (CLR) espera-se localizar quaisquer assemblagens que a aplicação utiliza na cache de assemblagem global ou a pasta de aplicação. Quando o CLR não ligar com êxito a uma assemblagem, receberá uma mensagem de erro semelhante à seguinte:
System.IO.FileNotFoundException. ficheiro ou assemblagem nome AssemblyName ou uma das respectivas dependências, não foi encontrado.
Pode utilizar vários métodos para localizar uma assemblagem que está localizada numa pasta diferente. Este artigo descreve três métodos seguintes.
Voltar ao topo

Método 1: Instalar as assemblagens na cache de assemblagem global

Este método requer que assinem uma assemblagem com um nome seguro. Para assinar uma assemblagem com um nome seguro e, em seguida, instalar a assemblagem na cache de assemblagem global, siga estes passos:
  1. Nome de uma assemblagem utilizando um nome seguro. Para o fazer, siga estes passos:
    1. Utilize a ferramenta nome seguro (Sn.exe) fornecida com o Microsoft .NET Framework software development kit (SDK) para gerar um par de chaves criptográficas.

      Na linha de comandos do Microsoft Visual Studio 2005 ou Microsoft Visual Studio. NET, escreva o seguinte comando:
      sn -k AssemblyName .snk
      Este comando gera e armazena um par de chaves num ficheiro denominado AssemblyName .snk.
    2. Incluir o seguinte atributo de nível de assemblagem no código de origem (AssemblyInfo.vb): 
      <Assembly: AssemblyKeyFile("AssemblyName.snk")>
  2. Utilize a ferramenta de cache de assemblagem global (Gacutil.exe) para registar a assemblagem da .NET Framework na cache de assemblagem global. Para o fazer, escreva o seguinte comando com o Visual Studio .NET linha de comandos:
    gacutil /i AssemblyName .dll
Para obter mais informações sobre como trabalhar com assemblagens e com a cache de assemblagem global, visite o seguinte Microsoft Developer Network (MSDN) Web site:
http://msdn2.microsoft.com/en-us/library/6axd4fx6(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/6axd4fx6(vs.71).aspx)
Para obter mais informações sobre como assinar uma assemblagem com um nome seguro, visite o seguinte site da Web MSDN:
http://msdn2.microsoft.com/en-us/library/xc31ft41(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/xc31ft41(vs.71).aspx)
Nota Este método poderá ser difícil e demorado se muitas assemblagens existem e se as assemblagens têm dependências de objectos COM (Component Object Model) da Microsoft. Quaisquer dependências de assemblagem também tem de ser detectáveis por CLR. Por conseguinte, se pretender instalar a assemblagem na cache de assemblagem global, de instalar também as dependências da assemblagem na cache de assemblagem global.
Voltar ao topo

Método 2: Utilizar um ficheiro Application.Config juntamente com a tag CodeBase

Utilizando um ficheiro de configuração de aplicação, pode especificar a localização na qual o CLR deve procurar assemblagens dependentes. Especificamente, utilize o código de código base . Utilizando este código, pode colocar as assemblagens numa pasta separada. No entanto, este método ainda requer a que nome de assemblagem de biblioteca utilizando um nome seguro. Para utilizar o ficheiro de configuração da aplicação, siga estes passos:
  1. Compile a assemblagem de biblioteca.
  2. Assinar a assemblagem utilizando um nome seguro.
  3. A partir da aplicação principal, adicione uma referência para a assemblagem de biblioteca e, em seguida, compilar a aplicação principal.
  4. Obter o token de chave pública a partir da assemblagem de biblioteca com nome seguro. Para o fazer, siga estes passos:
    1. Clique em Iniciar , clique em Todos os programas e, em seguida, clique em Microsoft Visual Studio .NET 2003 .

      Nota No Visual Studio 2005, clique em Iniciar , clique em todos os programas e, em seguida, clique em Microsoft Visual Studio 2005 .
    2. Clique em Ferramentas do Visual Studio .NET e clique em Visual Studio .NET 2003 comandos .

      Nota No Visual Studio 2005, clique em Visual Studio 2005 Tools e, em seguida, clique em Visual Studio .NET 2005 comandos .
    3. Altere o directório para a localização da assemblagem de biblioteca. Normalmente, a localização é a posição pasta do seu projecto de assemblagem de biblioteca.
    4. Escreva o seguinte comando e, em seguida, prima ENTER:
      NS -T MyLibrary .dll
      Nota Substitua o nome da assemblagem de biblioteca MyLibrary. Para se certificar de que é devolvido o valor correcto, certifique-se que utiliza um T em maiúsculas a -T mudar.
    5. Este comando devolve um valor hexadecimal que representa o token de chave pública de assemblagem de biblioteca. Efectue uma cópia do valor hexadecimal que vai ser utilizada no ficheiro de configuração da aplicação.
  5. Obter a versão de assemblagem a partir da assemblagem de biblioteca com nome seguro. Para obter a versão de assemblagem, utilize um dos seguintes métodos:
    • Propriedades de ficheiro Explorador do Windows método A:
      1. No Explorador do Windows, clique com o botão direito do rato a assemblagem de biblioteca e, em seguida, clique em Propriedades .
      2. Na caixa de diálogo Propriedades , clique no separador versão .
      3. Em outra informações de versão , clique em Versão de assemblagem . Efectue uma cópia deste valor de versão que irão ser utilizados no ficheiro de configuração da aplicação.
    • Método B: MSIL desintegrador (ILDASM)
      1. No Visual Studio .NET 2003 aviso de comando, escreva ILDASM e, em seguida, prima ENTER.
      2. No menu ficheiro , clique em Abrir .
      3. Faça clique sobre a assemblagem personalizada e, em seguida, clique em Abrir .
      4. No painel inferior, localize a versão de assemblagem (. ver). Segue-se um exemplo da versão de assemblagem: 
        .assembly yourAssemblyName
{
  .ver 1:0:1969:29451
}
        NOTA: neste exemplo, a versão de assemblagem é 1.0.1969.29541.
  6. Crie um ficheiro de configuração aplicação. Para o fazer, siga estes passos:
    1. Cole o seguinte código XML no bloco de notas: 
      <configuration>
   <runtime>
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <dependentAssembly>
            <assemblyIdentity name="MyLibrary"
                              culture="neutral" 
                              publicKeyToken="fa4e781ae585ee8a"/>

            <codeBase version="1.0.1074.32347"
		        href="FILE://C:/assemblies/myLibrary.dll"/>
         </dependentAssembly>
      </assemblyBinding>
   </runtime>
</configuration>
    2. Altere os seguintes atributos de elemento XML.
      Reduzir esta tabelaExpandir esta tabela
      Atributo de elementoEfectuar esta alteração
      nome assemblyIdentity Alterar MyLibrary para o nome da assemblagem de biblioteca.
      assemblyIdentity publicKeyToken Altere o atributo publicKeyToken para o valor de chave pública token que copiou no passo 4.
      codeBase versão Altere o atributo de versão para o valor da versão que copiou no passo 5.
      codeBase href Altere o atributo ' href ' para apontar para o nome do caminho completo e o nome da assemblagem de biblioteca.
    3. Guarde o ficheiro como a assemblagem principal nome de ficheiro .exe. Utilize .config como a extensão de nome de ficheiro. Por exemplo, se a assemblagem principal é o nome "MyProject.exe", o nome de ficheiro de configuração da aplicação é "MyProject.exe.config." Tem de guardar este ficheiro na mesma pasta onde se encontra a assemblagem de aplicação principal.
Para obter mais informações, visite os seguintes Web sites da MSDN:
Especificar localização de uma assemblagem
http://msdn2.microsoft.com/en-us/library/4191fzwb(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/4191fzwb(vs.71).aspx)

<codebase> elemento
http://msdn2.microsoft.com/en-us/library/efs781xb(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/efs781xb(vs.71).aspx)

Como o tempo de execução localiza assemblagens
http://msdn2.microsoft.com/en-us/library/yx7xezcf(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/yx7xezcf(vs.71).aspx)
Voltar ao topo

Método 3: Utilizar o método System.Reflection.Assembly.LoadFrom

Este método utiliza o método Assembly.LoadFrom para carregar uma assemblagem explicitamente um nome de caminho totalmente qualificado e de um nome de ficheiro totalmente qualificado. Para o fazer, siga estes passos:
  1. Compile a assemblagem de biblioteca.
  2. Utilizar código semelhante ao exemplo de código seguinte para carregar a assemblagem: 
    Dim yourAssembly As System.Reflection.Assembly = _
      System.Reflection.Assembly.LoadFrom("c:\yourAssembly.dll")
Nota Se tiver quaisquer assemblagens dependentes, a deve localizá-los no mesmo caminho onde está localizada a assemblagem principal.

Para mais informações sobre o método Assembly.LoadFrom , visite o seguinte site da Web MSDN:
http://msdn2.microsoft.com/en-us/library/system.reflection.assembly.loadfrom(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/system.reflection.assembly.loadfrom(vs.71).aspx)
Voltar ao topo

Método 4: Utilizar o evento AssemblyResolve

O evento AssemblyResolve ocorre sempre que o CLR tenta sem êxito ligar a uma assemblagem. Utilize o método ' AddHandler na aplicação para adicionar um processador de eventos que devolve a assemblagem correcta sempre que ocorre o evento AssemblyResolve .

Nota Este método é não requerem que nome as assemblagens utilizando nomes fortes.

O processador de eventos AssemblyResolve tem de devolver um objecto [assemblagem] que representa a assemblagem para o qual o CLR deve ligar. Normalmente, pode utilizar o método Assembly.LoadFrom para carregar a assemblagem. Volte a assemblagem carregada.

Nota O processador de eventos deve estar localizado num procedimento que não contém quaisquer referências a assemblagens relocalizadas. Além disso, o processador de eventos tem de ser chamado antes de qualquer código que depende de assemblagens relocalizadas é designado por.

O código seguinte é um exemplo de uma aplicação que carrega uma assemblagem utilizando o evento AssemblyResolve : 
Module Module1
    Sub Main()
        Dim f As Form1

        'Set up event handler for AssemblyResolve event
        AddHandler AppDomain.CurrentDomain.AssemblyResolve, _
                   AddressOf MyResolveEventHandler

        f = New Form1()
        Application.Run(f)
    End Sub

    Function MyResolveEventHandler(ByVal sender As Object, _
                                   ByVal args As ResolveEventArgs) As [Assembly]

        'Load the assembly from the correct location and return the assembly
        'This handler is only called if we try to bind to the assembly and the attempt fails.
        Dim MyAssembly As [Assembly]
        MyAssembly = [Assembly].LoadFrom("C:\assemblies\MyLibrary.dll")
        Return MyAssembly
    End Function
End Module


'Some sample code in Form1 which depends on the external assembly
Private Sub Button1_Click(ByVal sender As System.Object, _
                          ByVal e As System.EventArgs) Handles Button1.Click

        Dim x As MyLibrary.Application
        x = New MyLibrary.Application()
        x.MyMethod()
    End Sub
End Class
para obter mais informações sobre o evento AppDomain.AssemblyResolve , visite o seguinte site da Web MSDN:
http://msdn2.microsoft.com/en-us/library/system.appdomain.assemblyresolve(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/system.appdomain.assemblyresolve(vs.71).aspx)
Voltar ao topo

Referências

Para obter mais informações, clique no número de artigo que se segue para visualizar o artigo na Microsoft Knowledge Base:
302340  (http://support.microsoft.com/kb/302340/ ) Como criar uma assemblagem com um nome seguro no .NET Framework SDK
Voltar ao topo
A informação contida neste artigo aplica-se a:
  • Microsoft Visual Basic 2005
  • Microsoft Visual Basic .NET 2003 Standard Edition
  • Microsoft Visual Basic .NET 2002 Standard Edition
Voltar ao topo
Palavras-chave: 
kbmt kbvs2005swept kbvs2005applies kbprogramming kbhowto kbinfo KB897297 KbMtpt
Voltar ao topo
Tradução automáticaTradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 897297  (http://support.microsoft.com/kb/897297/en-us/ )
Voltar ao topo