duas DLLs diferentes com o mesmo namespace

Eu tenho dois arquivos DLL que têm o mesmo espaço para nome, mas eles têm methods e tipos diferentes. Como posso referenciar as duas DLLs no meu projeto e usar seus methods e tipos?

By the way, essas duas DLLs têm alguns methods e tipos com o mesmo nome, mas implementação diferente e alguns methods e tipos exclusivos.

Não há nada de especial que você precise fazer – basta referenciá-los e usar os tipos. Os namespaces podem se estender por vários assemblies sem problemas, porque eles não são tipos realmente opacos. Um namespace é apenas uma forma de adicionar um prefixo comum a todos os tipos que ele contém, permitindo que você tenha vários tipos de mesmo nome em diferentes namespaces. (A estrutura não os vê como tendo os mesmos nomes, porque ele vê o nome “totalmente qualificado” de tudo – que tem um alias e um espaço de nomes anexado à frente dele).

No raro evento que você faz referência a 2 assemblies que possuem os mesmos nomes de tipo e os mesmos namespaces (como 2 versões diferentes da mesma dll) – você pode distinguir qual assembly usar para um determinado tipo usando um alias. O alias padrão para todas as referências é global , mas você pode especificar seu próprio alias para qualquer assembly quando fizer referência a ele (usando um switch de compilador – ou apenas usar a checkbox de propriedades no Visual Studio) – e ter uma cláusula extern alias em o topo do seu arquivo de código onde você o usa – você acessaria os tipos de assemblies diferentes com ::MyNamespace.Type

Se você tem 2 tipos com o mesmo nome (note que o nome inclui o namespace), mas em diferentes DLLs e você está interessado em usar os dois, então você pode fazer isso.

Resposta curta

Você tem tipo Acme.Foo em 2 DLLs diferentes e você deseja usá-los. Dê à referência um alias na janela de propriedades de referência (View | Properties Window) e use-a assim:

 extern alias TheAliasYouGaveTheReference TheAliasYouGaveTheReference::Acme.Foo f = new TheAliasYouGaveTheReference::Acme.Foo();

O namespace padrão é global para qualquer programa C #, mas observe acima que estamos usando o alias que criamos em vez de global .

A melhor abordagem é NÃO entrar em uma situação como esta em primeiro lugar, se ambas as montagens forem suas, então não crie 2 tipos com exatamente o mesmo nome no mesmo namespace. Mas às vezes nós não controlamos o código-fonte, então, para aqueles momentos, a solução acima pode ser usada.

Resposta longa

Estou copiando a maior parte do artigo daqui, por isso é registrado aqui, caso o artigo não esteja mais disponível.

Como você entra em uma situação como essa?

Primeiramente, veja como você pode replicar o cenário para que fique bem claro do que estamos falando:

Criar uma biblioteca de classs c # chamada FooVersion1

Substitua o código do modelo em Class1.cs com o seguinte:

 using System; namespace Acme { public class Foo { public void Bar() { Console.WriteLine("Bar"); } } }

Clique com o botão direito do mouse na solução no gerenciador de soluções e selecione Incluir | Novo projeto
Salve o projeto atual (aplicável apenas em expresso)
Selecione uma biblioteca de classs na checkbox de diálogo new project e altere o nome do projeto para FooVersion2 e pressione OK

Substitua o código em Class1.cs com o seguinte:

 using System; namespace Acme { public class Foo { public void Bar() { Console.WriteLine("Bar"); } public void Goo() { Console.WriteLine("Goo"); } } }

Uso do tipo no aplicativo

Ok, agora temos dois conjuntos diferentes contendo Acme.Foo . Vamos agora criar um aplicativo de console e tentar usar cada um deles.

Clique com o botão direito do mouse na solução no gerenciador de soluções e selecione Incluir | Novo projeto
Selecione um aplicativo de console e chame-o de consumidor
Clique com o botão direito em Consumer e selecione “Set as startup project”
Clique com o botão direito do mouse no nó de referências no projeto Consumidor e selecione ‘Incluir Referência’
Clique na guia projetos e selecione várias opções FooVersion1 e FooVersion2 Clique em OK
Adicione a seguinte linha ao principal no tipo de programa do projeto de consumidor:
```
 Acme.Foo f = new Acme.Foo(); 
```

Construa a solução via Ctrl + Shift + B (ou F6) Observe que você obtém dois erros de compilation [como mostrado abaixo]:

insira a descrição da imagem aqui

O conserto

Veja como podemos corrigi-lo:

Abra o solution explorer e selecione FooVersion1 na pasta References do projeto Consumer
Clique em F4 (ou selecione View | Properties Window)
Altere a propriedade Aliases para FooVersion1
Construa a solução
Agora tudo vai construir corretamente, porque Acme.Foo se refere sem ambiguidade ao FooVersion2
Adicione a seguinte diretiva à parte superior do Program.cs no projeto Consumidor:
```
 extern alias FooVersion1; 
```

Altere o uso do Acme.Foo para:

 FooVersion1::Acme.Foo f = new FooVersion1::Acme.Foo(); f.Bar();

Observe que quando você digita ‘f’. A lista de conclusão contém apenas os methods em FooVersion1 de Acme.Foo (nomeadamente, não inclui Goo)
Construa a solução e tudo vai construir corretamente
Por fim, adicione o seguinte código em f.Bar () em Program.cs do projeto Consumidor:
```
 Acme.Foo f2 = new Acme.Foo(); f2.Goo(); 
```
Observe que a lista de conclusão da f2 contém o Goo.
Construa novamente usando Ctrl + Shift + B e observe que ainda não há erros de compilation

você pode usar o recurso de alias da opção de compilador / reference (Importar Metadados) (Opções do Compilador C #) para resolver seus problemas, leia aqui para obter mais detalhes