System.Runtime.CompilerServices.InternalsVisibleToAttribute classe

Este artigo fornece observações complementares à documentação de referência para essa API.

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

Normalmente, tipos e membros com internal escopo em C# ou Friend escopo no Visual Basic são visíveis somente no assembly no qual eles são definidos. Tipos e membros com protected internal escopo (Protected Friend escopo no Visual Basic) são visíveis somente em seu próprio assembly ou para tipos que derivam de sua classe de contenção. Tipos e membros com private protected escopo (Private Protected escopo no Visual Basic) são visíveis na classe que contém ou em tipos que derivam de sua classe que contém dentro do assembly atual

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

Observação

No caso de private protected membros (Private Protected no Visual Basic), o InternalsVisibleToAttribute atributo estende a acessibilidade somente para tipos que derivam da classe que contém do membro.

O atributo é aplicado no nível de assembly. 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 assembly de amigo único que pode acessar os tipos internos e os membros do assembly atual. Você pode definir vários assemblies de amigos de duas maneiras. Eles podem aparecer como atributos individuais em nível de 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 separadas InternalsVisibleToAttribute , mas uma única assembly palavra-chave, como ilustra o exemplo a seguir.

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

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

A montagem do amigo é identificada InternalsVisibleToAttribute pelo construtor. O assembly atual e o assembly amigo devem ser 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.

Se ambos os assemblies forem assinados com um nome forte, o argumento para o InternalsVisibleToAttribute construtor deverá 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 o CultureInfocampo , ou no argumento, Versionos ProcessorArchitecture 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 tiverem nomes fortes, uma MethodAccessException exceção será lançada na primeira vez que o assembly amigo especificado acessar o assembly que contém o InternalsVisibleToAttribute atributo.

Para obter mais informações sobre como usar esse atributo, consulte Assemblies de amigos e assemblies de amigos em C++.

Obtenha a chave pública completa

Você pode usar a Strong Name Tool (Sn.exe) para recuperar a chave pública completa de um arquivo de chave de nome forte (.snk). Para fazer isso, execute as seguintes etapas:

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

   Sn -p <snk_file> <outfile>

2. Exiba a chave pública completa para o console:

   Sn -tp <outfile>

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

Compilar o assembly do amigo 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 de compilador /out . Isso é necessário porque o compilador ainda não gerou o nome do assembly que está compilando no momento em que ele está se associando às referências externas. A opção de compilador /out é opcional para o compilador do Visual Basic e a opção de compilador -out ou -o correspondente não deve ser usada ao compilar assemblies amigos com o compilador F#.

Compilar o assembly amigo com C++

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