Diferença entre LoadFile e LoadFrom com .NET Assemblies?

Eu estava olhando para a documentação do msdn e ainda estou um pouco confuso sobre o que exatamente é a diferença entre o uso de LoadFile e LoadFrom ao carregar um assembly. Alguém pode fornecer um exemplo ou uma analogia para melhor descrevê-lo. A documentação do MSDN me confundiu mais. Além disso, é ReflectionOnlyLoadFrom o mesmo que LoadFrom exceto que ele carrega o assembly somente no modo de reflection.

Como minha experiência com o .NET não é a melhor, aqui estão algumas questões relacionadas à documentação do MSDN usando o LoadFile:

1) O que significa por LoadFile examina assemblies que têm a mesma identidade, mas estão localizados em caminhos diferentes? Qual é a identidade (exemplo)?

2) Ele afirma que o LoadFile não carrega arquivos no ‘Contexto LoadFrom’ e não resolve dependencies usando o caminho de carregamento. O que isso significa, alguém pode fornecer um exemplo?

3) Por último, afirma que LoadFile é útil neste cenário limitado porque LoadFrom não pode carregar assemblies que tenham as mesmas identidades, mas caminhos diferentes; ele só carregará a primeira assembly desse tipo, o que novamente me leva à mesma pergunta, qual é a identidade das montagens?

Isso esclarece isso?

 // path1 and path2 point to different copies of the same assembly on disk: Assembly assembly1 = Assembly.LoadFrom(path1); Assembly assembly2 = Assembly.LoadFrom(path2); // These both point to the assembly from path1, so this is true Console.WriteLine(assembly1.CodeBase == assembly2.CodeBase); assembly1 = Assembly.LoadFile(path1); assembly2 = Assembly.LoadFile(path2); // These point to different assemblies now, so this is false Console.WriteLine(assembly1.CodeBase == assembly2.CodeBase); 

Edit : para responder às perguntas que você levantou em sua pergunta revisada, você definitivamente quer ler Suzanne Cook em Assembly Identity .

Existem muitas regras que controlam como os assemblies são carregados, e alguns deles têm a ver com como eles resolvem dependencies – se o seu AssemblyA é dependente do AssemblyB, onde o .NET deve procurar o AssemblyB? No Global Assembly Cache, o mesmo diretório encontrou o AssemblyA ou algum outro lugar completamente? Além disso, se encontrar várias cópias dessa assembly, como escolher qual delas usar?

LoadFrom tem um conjunto de regras, enquanto LoadFile tem outro conjunto de regras. É difícil imaginar muitas razões para usar o LoadFile , mas se você precisar usar reflection em diferentes cópias do mesmo assembly, estará lá para você.

Do blog de Suzanne Cook :

LoadFile vs. LoadFrom

Tenha cuidado – estas não são a mesma coisa.

LoadFrom () passa por Fusion e pode ser redirecionado para outro assembly em um caminho diferente, mas com essa mesma identidade, se já estiver carregado no contexto LoadFrom.

O LoadFile () não é vinculado por meio do Fusion – o carregador simplesmente avança e carrega exatamente * o que o chamador solicitou. Ele não usa o contexto Load ou LoadFrom.

Então, LoadFrom () normalmente dá o que você pediu, mas não necessariamente. LoadFile () é para aqueles que realmente querem exatamente o que é solicitado. (* No entanto, a partir de v2, a política será aplicada a LoadFrom () e LoadFile (), portanto, LoadFile () não será necessariamente exatamente o que foi solicitado. Além disso, a partir de v2, se um assembly com sua identidade estiver em No GAC, a cópia do GAC será usada. Use ReflectionOnlyLoadFrom () para carregar exatamente o que você quer – mas, note que os assemblies carregados dessa maneira não podem ser executados.)

LoadFile () tem um problema. Como não usa um contexto de binding, suas dependencies não são encontradas automaticamente em seu diretório. Se eles não estiverem disponíveis no contexto Load, você deverá se inscrever no evento AssemblyResolve para vincular-se a eles.

Veja aqui

Veja também o artigo Escolhendo um Contexto de Ligação no mesmo blog.

Depois de muito arranhar a cabeça, descobri uma diferença nesta tarde.

Eu queria carregar uma DLL em tempo de execução, e a DLL vivia em outro diretório. Essa DLL tinha suas próprias dependencies (DLLs) que também viviam nesse mesmo diretório.

LoadFile (): Carregou a DLL específica, mas não as dependencies. Então, quando a primeira chamada foi feita dentro da DLL para uma dessas outras DLLs, ela lançou um FileNotFoundException.

LoadFrom (): carregou a DLL que eu especifiquei e também todas as dependencies que residiam nesse diretório.

Uma diferença que eu notei é:

Assembly.LoadFile – Carrega assembly em diferentes AppDomain com direitos de usuário limitados (diffrence principel). operações como serilização / deserilização não puderam ser realizadas.

Assembly.LoadFrom – Carrega o assembly no mesmo AppDomain com os mesmos direitos de usuário (mesmo principel).

Nota: Se um conjunto for carregado usando um caminho 8.3 e, em seguida, a partir de um caminho não 8.3, eles serão vistos como assemblies diferentes, mesmo que sejam a mesma DLL física.

O .NET tem contexto de carregamento diferente. Suzanne Cook escreveu sobre eles aqui: http://blogs.msdn.com/suzcook/archive/2003/05/29/57143.aspx

Esta é a maneira .Net quarentenas que as referências não são misturadas.

No meu caso, eu só tinha que simplesmente excluir o cache de aplicativos ASP localizado @ C:\Windows\Microsoft.NET\Framework\[asp version]\Temporary ASP.NET Files . É reconstruído quando o site é executado pela primeira vez. Certifique-se de parar o IIS primeiro.

Espero que isso ajude alguém como ele fez para mim.

Segundo a documentação:

LoadFile (String): Carrega o conteúdo de um arquivo de assembly dado um caminho de arquivo.

LoadFrom (String): carrega um assembly dado seu nome de arquivo ou caminho.