Execução lado a lado no .NET Framework

A execução lado a lado é a capacidade de executar várias versões de um aplicativo ou componente no mesmo computador. Você pode ter várias versões do Common Language Runtime e várias versões de aplicativos e componentes que usam uma versão do tempo de execução, no mesmo computador ao mesmo tempo.

A ilustração a seguir mostra vários aplicativos usando duas versões diferentes do tempo de execução no mesmo computador. Os aplicativos A, B e C usam o tempo de execução versão 1.0, enquanto o aplicativo D usa o tempo de execução versão 1.1.

O .NET Framework consiste no Common Language Runtime e uma coleção de assemblies que contêm os tipos de API. As versões do ambiente de execução e dos assemblies do .NET Framework são geridas de forma separada. Por exemplo, a versão 4.0 do tempo de execução é, na verdade, a versão 4.0.319, enquanto a versão 1.0 dos assemblies do .NET Framework é a versão 1.0.3300.0.

A ilustração a seguir mostra vários aplicativos usando duas versões diferentes de um componente no mesmo computador. Os aplicativos A e B usam a versão 1.0 do componente, enquanto o aplicativo C usa a versão 2.0 do mesmo componente.

A execução lado a lado oferece mais controle sobre quais versões de um componente um aplicativo se vincula e mais controle sobre qual versão do tempo de execução um aplicativo usa.

Benefícios da execução lado a lado

Antes do Windows XP e do .NET Framework, os conflitos de DLL ocorriam porque os aplicativos não conseguiam distinguir entre versões incompatíveis do mesmo código. As informações de tipo contidas em uma DLL foram vinculadas apenas a um nome de arquivo. Um aplicativo não tinha como saber se os tipos contidos em uma DLL eram os mesmos tipos com os quais o aplicativo foi criado. Como resultado, uma nova versão de um componente pode substituir uma versão mais antiga e interromper aplicativos.

A execução lado a lado e o .NET Framework fornecem os seguintes recursos para eliminar conflitos de DLL:

• Assembléias com nomes fortes.

  A execução lado a lado utiliza assemblies com nome forte para vincular informações de tipo a uma versão específica de um assembly. Isso impede que um aplicativo ou componente se vincule a uma versão inválida de um assembly. Os assemblies de nome forte também permitem que várias versões de um arquivo existam no mesmo computador e sejam usadas por aplicativos. Para obter mais informações, consulte Strong-Named assemblies.

• Armazenamento de código com reconhecimento de versão.

  O .NET Framework fornece armazenamento de código com reconhecimento de versão no cache de assembly global. A cache de assembly global é um cache de código do sistema presente em todos os computadores que têm o .NET Framework instalado. Ele armazena assemblies com base em informações de versão, cultura e editor e suporta várias versões de componentes e aplicativos. Para obter mais informações, consulte Global Assembly Cache.

• Isolamento.

  Usando o .NET Framework, você pode criar aplicativos e componentes que são executados isoladamente. O isolamento é um componente essencial da execução lado a lado. Isso envolve estar ciente dos recursos que você está usando e compartilhar recursos com confiança entre várias versões de um aplicativo ou componente. O isolamento também inclui o armazenamento de arquivos de uma maneira específica da versão. Para obter mais informações sobre isolamento, consulte Diretrizes para criar componentes para execução lado a lado.

Compatibilidade de versões

As versões 1.0 e 1.1 do .NET Framework são projetadas para serem compatíveis entre si. Um aplicativo criado com o .NET Framework versão 1.0 deve ser executado na versão 1.1 e um aplicativo criado com o .NET Framework versão 1.1 deve ser executado na versão 1.0. Observe, no entanto, que os recursos de API adicionados na versão 1.1 do .NET Framework não funcionarão com a versão 1.0 do .NET Framework. Os aplicativos criados com a versão 2.0 serão executados somente na versão 2.0. Os aplicativos da versão 2.0 não serão executados na versão 1.1 ou anterior.

As versões do .NET Framework são tratadas como uma única unidade que consiste no ambiente de execução e nos assemblies associados do .NET Framework (um conceito conhecido como unificação de assembly). Você pode redirecionar a associação de assembly para incluir outras versões dos assemblies do .NET Framework, mas substituir a associação de assembly padrão pode ser arriscado e deve ser rigorosamente testado antes da implementação.

Localizando informações de versão do Runtime

As informações sobre com qual versão de tempo de execução um aplicativo ou componente foi compilado e quais versões do tempo de execução o aplicativo requer para ser executado são armazenadas em dois locais. Quando um aplicativo ou componente é compilado, as informações sobre a versão de tempo de execução usada para compilá-lo são armazenadas no executável gerenciado. As informações sobre as versões de tempo de execução que o aplicativo ou componente requer são armazenadas no arquivo de configuração do aplicativo.

Informação sobre a versão de tempo de execução no executável gerido

O cabeçalho do arquivo executável portátil (PE) de cada aplicativo gerenciado e componente contém informações sobre a versão de tempo de execução com a qual ele foi criado. O common language runtime usa essas informações para determinar a versão mais provável do tempo de execução que o aplicativo precisa executar.

Informações da versão de runtime no ficheiro de configuração da aplicação

Além das informações no cabeçalho do arquivo PE, um aplicativo pode ser implantado com um arquivo de configuração do aplicativo que fornece informações de versão de tempo de execução. O arquivo de configuração do aplicativo é um arquivo baseado em XML que é criado pelo desenvolvedor do aplicativo e que acompanha um aplicativo. O<requiredRuntime> Elemento da <startup> secção, se estiver presente neste ficheiro, especifica quais as versões do tempo de execução e quais as versões de um componente que a aplicação suporta. Você também pode usar esse arquivo em testes para testar a compatibilidade de um aplicativo com diferentes versões do tempo de execução.

O código não gerenciado, incluindo aplicativos COM e COM+, pode ter arquivos de configuração de aplicativo que o tempo de execução usa para interagir com o código gerenciado. O arquivo de configuração do aplicativo afeta qualquer código gerenciado ativado por meio do COM. O arquivo pode especificar quais versões de tempo de execução ele suporta, bem como redirecionamentos de assembly. Por padrão, os aplicativos de interoperabilidade COM que chamam para código gerenciado usam a versão mais recente do tempo de execução instalada no computador.

Para obter mais informações sobre os arquivos de configuração do aplicativo, consulte Configurando aplicativos.

Determinar qual versão do tempo de execução deve ser carregada

O common language runtime usa as seguintes informações para determinar qual versão do tempo de execução deve ser carregada para um aplicativo:

• As versões de tempo de execução que estão disponíveis.

• As versões de tempo de execução suportadas por uma aplicação.

Versões de tempo de execução suportadas

O tempo de execução usa o arquivo de configuração do aplicativo e o cabeçalho do arquivo executável portátil (PE) para determinar qual versão do tempo de execução um aplicativo suporta. Se nenhum arquivo de configuração do aplicativo estiver presente, o tempo de execução carregará a versão de tempo de execução especificada no cabeçalho do arquivo PE do aplicativo, se essa versão estiver disponível.

Se um arquivo de configuração do aplicativo estiver presente, o tempo de execução determinará a versão de tempo de execução apropriada a ser carregada com base nos resultados do seguinte processo:

1. O runtime examina o <supportedRuntime> elemento Element no ficheiro de configuração da aplicação. Se uma ou mais das versões de runtime suportadas especificadas no <supportedRuntime> elemento estiverem presentes, o runtime carrega a versão de runtime especificada pelo primeiro <supportedRuntime> elemento. Se esta versão não estiver disponível, o runtime examina o próximo <supportedRuntime> elemento e tenta carregar a versão de runtime especificada. Se esta versão em tempo de execução não estiver disponível, os elementos subsequentes <supportedRuntime> são examinados. Se nenhuma das versões de tempo de execução suportadas estiver disponível, o tempo de execução falhará ao carregar uma versão de tempo de execução e exibirá uma mensagem para o usuário (consulte a etapa 3).

2. Durante a execução, o runtime lê o cabeçalho do arquivo PE do ficheiro executável da aplicação. Se a versão de tempo de execução especificada pelo cabeçalho do arquivo PE estiver disponível, o tempo de execução carregará essa versão. Se a versão em execução especificada não estiver disponível, o runtime procurará uma versão que a Microsoft considere compatível com a versão em execução no cabeçalho PE. Se essa versão não for encontrada, o processo continua para a etapa 3.

3. O ambiente de execução exibe uma mensagem informando que a versão de ambiente de execução suportada pela aplicação não está disponível. O tempo de execução não está carregado.

   Observação

   Você pode suprimir a exibição dessa mensagem usando o valor NoGuiFromShim na chave do Registro HKLM\Software\Microsoft\. NETFramework ou usando a variável de ambiente COMPLUS_NoGuiFromShim. Por exemplo, você pode suprimir a mensagem para aplicativos que normalmente não interagem com o usuário, como instalações autônomas ou serviços do Windows. Quando essa exibição de mensagem é suprimida, o tempo de execução grava uma mensagem no log de eventos. Defina o valor do Registro NoGuiFromShim como 1 para suprimir essa mensagem para todos os aplicativos em um computador. Como alternativa, defina a variável de ambiente COMPLUS_NoGuiFromShim como 1 para suprimir a mensagem para aplicativos executados em um contexto de usuário específico.

Nomes de montagem parcialmente qualificados e execução em paralelo

Como eles são uma fonte potencial de problemas relacionados, as referências de assembly parcialmente qualificadas podem ser usadas apenas para vincular a assemblies dentro de um diretório da aplicação. Evite referências de assembly parcialmente qualificadas no seu código.

Para atenuar referências de assembly parcialmente qualificadas no código, você pode usar o <elemento qualifyAssembly> em um arquivo de configuração de aplicativo para qualificar totalmente as referências de assembly parcialmente qualificadas que ocorrem no código. Use o <qualifyAssembly> elemento para especificar apenas os campos que não foram definidos na referência parcial. A identidade da assembleia listada no fullName atributo deve conter toda a informação necessária para qualificar totalmente o nome da assembleia: nome da assembleia, chave pública, cultura e versão.

O exemplo a seguir mostra a entrada do ficheiro de configuração da aplicação para qualificar completamente um assembly chamado myAssembly.

<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<qualifyAssembly partialName="myAssembly"
fullName="myAssembly,
      version=1.0.0.0,
publicKeyToken=...,
      culture=neutral"/>
</assemblyBinding>

Sempre que uma instrução de carga de assembly faz referência a myAssembly, essas definições de arquivo de configuração fazem com que o ambiente de execução traduza automaticamente a referência parcialmente qualificada de myAssembly para uma referência totalmente qualificada. Por exemplo, Assembly.Load("myAssembly") torna-se Assembly.Load("myAssembly, version=1.0.0.0, publicKeyToken=..., culture=neutral").

Tópicos relacionados

Referência

<supportedRuntime> Elemento