Como: Diagnosticar e corrigir problemas de compatibilidade do Assembly
Este tópico explica o que pode acontecer quando a versão de um assembly referenciado em tempo de compilação não coincidem com a versão do assembly referenciado em tempo de execução e como evitar o problema.
Quando um assembly é compilado, outros assemblies podem ser consultados com o #using sintaxe. Durante a compilação, esses assemblies são acessados pelo compilador. Informações desses assemblies são usadas para tomar decisões de otimização.
Entretanto, se o assembly referenciado é alterado e recompilado e você não recompilar o assembly de referência que depende dele, os assemblies podem não ser compatível. Decisões de otimização que eram válidas no primeiro podem não estar corretas em relação à nova versão do assembly. Vários erros de tempo de execução podem ocorrer devido a essas incompatibilidades. Não há nenhuma exceção específica que será produzida em tais casos. A maneira como a falha é relatada em tempo de execução depende da natureza da alteração de código que causou o problema.
Esses erros não devem ser um problema no seu código de produção final, contanto que o aplicativo inteiro é reconstruído para a versão do seu produto. Os assemblies que são lançados ao público devem ser marcados com um número de versão oficial, o que garantirá que esses problemas são evitados. For more information, see Versionamento de Assembly.
Diagnosticar e corrigir um erro de incompatibilidade
Se você encontrar exceções em tempo de execução ou outras condições de erro que ocorrem no código que faz referência a outro assembly e nenhuma outra causa identificada, talvez você esteja lidando com um assembly desatualizado.
Primeiro, isolar e reproduzir a exceção ou outra condição de erro. Um problema que ocorre devido a uma exceção desatualizada deve ser reproduzido.
Verifique o carimbo de hora de todos os assemblies referenciados em seu aplicativo.
Se os carimbos de hora de qualquer assemblies referenciados posteriores de carimbo de hora da última compilação do seu aplicativo, o aplicativo está desatualizado. Se isso ocorrer, recompilar seu aplicativo com o conjunto mais recente e faça as alterações de código necessárias.
Execute novamente o aplicativo, execute as etapas que reproduza o problema e verificar que a exceção não ocorre.
Exemplo
O programa a seguir ilustra o problema, reduzindo a acessibilidade de um método e tentando acessar esse método em outra montagem sem recompilar. Tente compilar changeaccess.cpp primeiro. Este é o assembly referenciado, que será alterado. Em seguida, compilar referencing.cpp. A compilação é bem-sucedida. Agora, reduza a acessibilidade do método chamado. Recompilar changeaccess.cpp com o sinalizador /DCHANGE_ACCESS. Isso torna o método protegido, em vez de particular, para que mais pode ser chamado legalmente. Sem recompilar referencing.exe, execute novamente o aplicativo. Uma exceção MethodAccessException será o resultado.
// changeaccess.cpp
// compile with: /clr:safe /LD
// After the initial compilation, add /DCHANGE_ACCESS and rerun
// referencing.exe to introduce an error at runtime. To correct
// the problem, recompile referencing.exe
public ref class Test {
#if defined(CHANGE_ACCESS)
protected:
#else
public:
#endif
int access_me() {
return 0;
}
};
// referencing.cpp
// compile with: /clr:safe
#using <changeaccess.dll>
// Force the function to be inline, to override the compiler's own
// algorithm.
__forceinline
int CallMethod(Test^ t) {
// The call is allowed only if access_me is declared public
return t->access_me();
}
int main() {
Test^ t = gcnew Test();
try
{
CallMethod(t);
System::Console::WriteLine("No exception.");
}
catch (System::Exception ^ e)
{
System::Console::WriteLine("Exception!");
}
return 0;
}