InternalsVisibleToAttribute Classe

Definição

public ref class InternalsVisibleToAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true, Inherited=false)]
public sealed class InternalsVisibleToAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true, Inherited=false)>]
type InternalsVisibleToAttribute = class
    inherit Attribute

Public NotInheritable Class InternalsVisibleToAttribute
Inherits Attribute

Herança

Object

Attribute

InternalsVisibleToAttribute

Atributos

AttributeUsageAttribute

Exemplos

Assembleias assinadas

O exemplo seguinte usa o InternalsVisibleToAttribute atributo para tornar um internal método nomeado AppendDirectorySeparator numa assembleia assinada visível para outra assembleia assinada. Define uma FileUtilities classe que inclui um método interno AppendDirectorySeparator . O InternalsVisibleToAttribute atributo é aplicado ao assembly que contém a FileUtilities classe. O atributo permite que um assembly nomeado Friend1 aceda a este membro interno.

//
// The source code should be saved in a file named Example1.cs. It 
// can be compiled at the command line as follows:
//
//    csc /t:library /keyfile:<snkfilename> Assembly1.cs
//
// The public key of the Friend1 file should be changed to the full
// public key stored in your strong-named key file.
//
using System;
using System.IO;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Friend1, PublicKey=002400000480000094" + 
                              "0000000602000000240000525341310004000" +
                              "001000100bf8c25fcd44838d87e245ab35bf7" +
                              "3ba2615707feea295709559b3de903fb95a93" +
                              "3d2729967c3184a97d7b84c7547cd87e435b5" +
                              "6bdf8621bcb62b59c00c88bd83aa62c4fcdd4" +
                              "712da72eec2533dc00f8529c3a0bbb4103282" +
                              "f0d894d5f34e9f0103c473dce9f4b457a5dee" +
                              "fd8f920d8681ed6dfcb0a81e96bd9b176525a" +
                              "26e0b3")]

public class FileUtilities
{
   internal static string AppendDirectorySeparator(string dir)
   {
      if (!dir.Trim().EndsWith(Path.DirectorySeparatorChar.ToString()))
         return dir.Trim() + Path.DirectorySeparatorChar;
      else
         return dir;
   }
}

'
' The source code should be saved in a file named Example1.cs. It 
' can be compiled at the command line as follows:
'
'    vbc Assembly1.vb /t:library /keyfile:<snkfilename> 
'
' The public key of the Friend1 file should be changed to the full
' public key stored in your strong-named key file.
'
Imports System.IO
Imports System.Runtime.CompilerServices

<Assembly:InternalsVisibleTo("Friend1, PublicKey=002400000480000094" + _
                             "0000000602000000240000525341310004000" + _
                             "001000100bf8c25fcd44838d87e245ab35bf7" + _
                             "3ba2615707feea295709559b3de903fb95a93" + _
                             "3d2729967c3184a97d7b84c7547cd87e435b5" + _
                             "6bdf8621bcb62b59c00c88bd83aa62c4fcdd4" + _
                             "712da72eec2533dc00f8529c3a0bbb4103282" + _
                             "f0d894d5f34e9f0103c473dce9f4b457a5dee" + _
                             "fd8f920d8681ed6dfcb0a81e96bd9b176525a" + _
                             "26e0b3")>

Public Class FileUtilities
   Friend Shared Function AppendDirectorySeparator(dir As String) As String
      If Not dir.Trim().EndsWith(Path.DirectorySeparatorChar) Then
         Return dir.Trim() + Path.DirectorySeparatorChar
      Else
         Return dir
      End If   
   End Function
End Class

Se o exemplo seguinte for compilado numa assembly com nome forte chamada Friend1, o Example.Main método em Friend1 pode chamar com sucesso o FileUtilities.AppendDirectorySeparator método, embora o método seja interno à Assembly1 assembleia. Se estiveres a compilar em C# a partir da linha de comandos, deves usar o comutador /out do compilador para garantir que o nome da assembly amiga está disponível quando o compilador se liga a referências externas.

//
// The source code should be saved in a file named Friend1.cs. It 
// can be compiled at the command line as follows:
//
//    csc /r:Assembly1.dll /keyfile:<snkfilename> /out:Friend1.dll Friend1.cs
//
// The public key of the Friend1 assembly should correspond to the public key
// specified in the class constructor of the InternalsVisibleTo attribute in the
// Assembly1 assembly.
//
using System;

public class Example
{
   public static void Main()
   {
      string dir = @"C:\Program Files";
      dir = FileUtilities.AppendDirectorySeparator(dir);
      Console.WriteLine(dir);
   }
}
// The example displays the following output:
//       C:\Program Files\

'
' The source code should be saved in a file named Friend1.vb. It 
' can be compiled at the command line as follows:
'
'    vbc Friend1.vb /r:Assembly1.dll /keyfile:<snkfilename> 
'
' The public key of the Friend1 assembly should correspond to the public key
' specified in the class constructor of the InternalsVisibleTo attribute in the
' Assembly1 assembly.
'
Module Example
   Public Sub Main()
      Dim dir As String = "C:\Program Files"
        dir = FileUtilities1.AppendDirectorySeparator(dir)
        Console.WriteLine(dir)
   End Sub
End Module
' The example displays the following output:
'       C:\Program Files\

Assembleias não assinadas

O exemplo seguinte usa o InternalsVisibleToAttribute atributo para tornar um internal membro de uma assembleia sem sinal visível para outra assembleia sem sinal. O atributo garante que o internalStringLib.IsFirstLetterUpperCase método num assembly nomeado UtilityLib é visível para o código num assembly chamado Friend2. Segue-se o código-fonte de UtilityLib.dll:

using System;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleToAttribute("Friend2")]

namespace Utilities.StringUtilities
{
   public class StringLib
   {
      internal static bool IsFirstLetterUpperCase(String s)
      {
         string first = s.Substring(0, 1);
         return first == first.ToUpper();
      }
   }
}

Imports System.Runtime.CompilerServices

<assembly: InternalsVisibleTo("Friend2")>

Namespace Utilities.StringUtilities
   Public Class StringLib
      Friend Shared Function IsFirstLetterUpperCase(s As String) As Boolean
         Dim first As String = s.Substring(0, 1)
         Return first = first.ToUpper()
      End Function
   End Class
End Namespace

O exemplo seguinte fornece o código-fonte da Friend2 assembleia. Note que, se estiver a compilar em C# a partir da linha de comandos, deve usar o interruptor do compilador /out para garantir que o nome da assembly amiga está disponível quando o compilador se liga a referências externas.

using System;

public class Example1
{
   public static void Main()
   {
      String s = "The Sign of the Four";
      //Console.WriteLine(Utilities.StringUtilities.StringLib.IsFirstLetterUpperCase(s));
   }
}

Module Example1
    Public Sub Main()
        Dim s As String = "The Sign of the Four"
        ' Console.WriteLine(Utilities.StringUtilities.StringLib.IsFirstLetterUpperCase(s))
    End Sub
End Module

Observações

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

Normalmente, tipos e membros com internal escopo em C# ou Friend escopo em Visual Basic são visíveis somente no assembly em que são definidos. Tipos e membros com protected internal escopo (Protected Friend escopo no Visual Basic) são visíveis somente na sua própria assembly ou a tipos que derivem da sua classe de contenção. Tipos e membros com âmbito private protected (Private Protected âmbito em Visual Basic) são visíveis na classe de contenção ou em tipos que derivam da sua classe de contenção dentro do conjunto atual.

O atributo InternalsVisibleToAttribute torna estes tipos e membros também visíveis para os tipos numa assembleia especificada, que é conhecida como uma assembleia amiga. Isso se aplica somente aos membros internal (Friend no Visual Basic), protected internal (Protected Friend no Visual Basic), e private protected (Private Protected no Visual Basic), mas não aos private.

O atributo é aplicado no nível de 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 conjunto de assemblagem amigo que pode acessar os tipos internos e membros do conjunto de assemblagem atual. Você pode definir várias montagens de amigos de duas maneiras. Eles podem aparecer como atributos individuais de nível de montagem, 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 amiga é identificada InternalsVisibleToAttribute pelo construtor. Tanto a assembleia atual quanto a assembleia amiga devem não estar assinadas, ou ambas as montagens devem ser assinadas 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 são 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 o CultureInfocampo , Versionou 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 amigo especificado acessar o assembly que contém o InternalsVisibleToAttribute atributo.

Para mais detalhes sobre como usar este atributo, consulte Assemblies Amigos e Assemblies Amigos C++.

Obtenha a chave pública completa

Você pode usar a Ferramenta de Nome Forte (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 ficheiro de chave com um nome forte num ficheiro 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.

Compile a montagem do amigo com C#

Se você usar o compilador C# para compilar o assembly friend, 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 para o assembly que está construindo no momento em que está vinculando a 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#.

Compile o assembly amigo com C++

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