InternalsVisibleToAttribute(String) Construtor

public:
 InternalsVisibleToAttribute(System::String ^ assemblyName);

public InternalsVisibleToAttribute(string assemblyName);

new System.Runtime.CompilerServices.InternalsVisibleToAttribute : string -> System.Runtime.CompilerServices.InternalsVisibleToAttribute

Public Sub New (assemblyName As String)

Parâmetros

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, pode chamar o FileUtilities.AppendDirectorySeparator método com sucesso, mesmo que o método seja interno à Assembly1 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.

//
// 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 = FileUtilities.AppendDirectorySeparator(dir)
      Console.WriteLine(dir)
   End Sub
End Module
' The example displays the following output:
'       C:\Program Files\

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

Assembleias não assinadas

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;
using Utilities.StringUtilities;

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

Imports Utilities.StringUtilities

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

Observações

O InternalsVisibleToAttribute construtor define uma assembleia amiga, que é uma assembleia que tem acesso aos tipos e membros protegidos internos e privados da assembleia atual.

Tanto a assembleia atual como a de amigos devem estar sem assinatura, ou ambas devem ser assinadas com um nome forte. (Para mais informações sobre assemblies com nomes fortes, veja Criar e usar assemblies com nomes fortes.) Se ambos estiverem sem sinal, o assemblyName argumento consiste no nome da assembly amiga, especificado sem caminho de diretório ou extensão de ficheiro. Se ambos estiverem assinados, assemblyName consiste no nome da assembly amiga sem o caminho do diretório ou extensão do nome do ficheiro, juntamente com a sua chave pública completa (mas não o seu token de chave pública). Os outros componentes de um nome forte, como aqueles que fornecem informação de cultura, versão ou arquitetura do processador, não podem ser especificados no assemblyName argumento.

Pode usar Sn.exe (Strong Name Tool) para recuperar a chave pública completa a partir de um ficheiro de chave com 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 -psnk_fileficheiro externo

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

   Ficheiro externoSn -tp

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

Para mais informações sobre como usar o InternalsVisibleToAttribute atributo, consulte os seguintes artigos:

• Assemblagens de Amigos (C++)

• Assembleias de amigos