Classe System.Runtime.CompilerServices.InternalsVisibleToAttribute

Este artigo fornece comentários complementares à documentação de referência para esta API.

O InternalsVisibleToAttribute atributo especifica que os tipos normalmente visíveis somente dentro do assembly atual são visíveis para um assembly especificado.

Normalmente, tipos e membros com escopo internal em C# ou Friend escopo no Visual Basic são visíveis apenas no assembly em que são definidos. Tipos e membros com protected internal escopo (Protected Friend escopo no Visual Basic) são visíveis apenas por sua própria montagem ou para tipos que derivam de sua classe que os contém. Tipos e membros com private protected escopo (Private Protected escopo no Visual Basic) são visíveis na classe que os contém ou em tipos que derivam da classe que os contém dentro do assembly atual

O atributo InternalsVisibleToAttribute torna esses tipos e membros visíveis também para os tipos em um assembly especificado, que é conhecido como um assembly amigável. Isso se aplica apenas a internal (Friend no Visual Basic), protected internal (Protected Friend no Visual Basic) e private protected (Private Protected no Visual Basic), mas não a private.

Observação

No caso de membros private protected (Private Protected no Visual Basic), o atributo InternalsVisibleToAttribute estende a acessibilidade apenas a tipos derivados da classe de contenção do membro.

O atributo é aplicado no nível da montagem. Isso significa que ele pode ser incluído no início de um arquivo de código-fonte ou pode ser incluído no arquivo AssemblyInfo em um projeto do Visual Studio. Você pode usar o atributo para especificar um único assembly amigável que possa acessar os tipos e membros internos do assembly atual. Você pode definir vários assemblies amigáveis de duas maneiras. Eles podem aparecer como atributos individuais no nível do assembly, como ilustra o exemplo a seguir.

[assembly:InternalsVisibleTo("Friend1a")]
[assembly:InternalsVisibleTo("Friend1b")]

<assembly:InternalsVisibleTo("Friend1a")>
<assembly:InternalsVisibleTo("Friend1b")>

Eles também podem aparecer com tags InternalsVisibleToAttribute separadas, mas uma única assembly palavra-chave, como ilustra o exemplo a seguir.

[assembly:InternalsVisibleTo("Friend2a"), 
          InternalsVisibleTo("Friend2b")]

<Assembly:InternalsVisibleTo("Friend2a"), _
 Assembly:InternalsVisibleTo("Friend2b")>

O assembly amigável é identificado pelo construtor InternalsVisibleToAttribute. Tanto o assembly atual quanto o assembly amigável devem estar não assinados ou ambos os assemblies devem ser assinados com um nome forte.

Se ambos os assemblies não estiverem assinados, o assemblyName argumento consistirá no nome do assembly amigo, especificado sem um caminho de diretório ou extensão de nome de arquivo.

Caso ambos os assemblies estejam assinados com um nome forte, o argumento para o InternalsVisibleToAttribute construtor deve consistir no nome do assembly sem seu caminho de diretório ou extensão de nome de arquivo, juntamente com a chave pública completa (e não seu token de chave pública). Para obter a chave pública completa de um assembly de nome forte, consulte a seção Obter a chave pública completa mais adiante neste artigo. Para obter mais informações sobre como usar InternalsVisibleToAttribute com assemblies de nome forte, consulte o InternalsVisibleToAttribute construtor.

Não inclua valores para os campos CultureInfo, Version ou ProcessorArchitecture no argumento; os compiladores Visual Basic, C# e C++ tratam isso como um erro do compilador. Se você usar um compilador que não o trate como um erro (como o IL Assembler (ILAsm.exe)) e os assemblies forem de nome forte, uma MethodAccessException exceção será lançada na primeira vez que o assembly amigável especificado acessar o assembly que contém o InternalsVisibleToAttribute atributo.

Para obter mais informações sobre como usar esse atributo, consulte assemblies amigáveis e assemblies amigáveis em C++.

Obter a chave pública completa

Você pode usar a Ferramenta de Nome Forte (Sn.exe) para recuperar a chave pública integral de um arquivo de chave com nome forte (.snk). Para fazer isso, execute as seguintes etapas:

1. Extraia a chave pública do arquivo de chave com nome forte para um arquivo separado:

   Sn -p <snk_file> <outfile>

2. Exiba a chave pública completa no console:

   Sn -tp <outfile>

3. Copie e cole o valor completo da chave pública no código-fonte.

Compilar o assembly amigável com C#

Se você usar o compilador C# para compilar o assembly amigo, deverá especificar explicitamente o nome do arquivo de saída (.exe ou .dll) usando a opção do compilador /out . Isso é necessário porque o compilador ainda não gerou o nome do assembly que está criando no momento em que está associando a referências externas. A opção do compilador /out é opcional para o compilador do Visual Basic e a opção correspondente do compilador -out ou -o não deve ser usada ao compilar assemblies amigáveis com o compilador F#.

Compilar o assembly amigável com C++

No C++, a fim de tornar os membros internos habilitados pelo atributo InternalsVisibleToAttribute acessíveis a um assembly amigo, você deve usar o atributo as_friend na diretiva C++. Para obter mais informações, consulte Assemblies amigáveis (C++).