InternalsVisibleToAttribute(String) Construtor

Referência

Definição

Namespace:: System.Runtime.CompilerServices

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: InternalsVisibleToAttribute.cs

Origem:: InternalsVisibleToAttribute.cs

Origem:: InternalsVisibleToAttribute.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Inicializa uma nova instância da classe InternalsVisibleToAttribute com o nome do assembly amigo especificado.

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

assemblyName: String

O nome de um assembly amigo.

Exemplos

assemblies assinados

O exemplo a seguir usa o atributo InternalsVisibleToAttribute para tornar um método internal chamado AppendDirectorySeparator em um assembly assinado visível para outro assembly assinado. Ele define uma classe FileUtilities que inclui um método de AppendDirectorySeparator interno. O atributo InternalsVisibleToAttribute é aplicado ao assembly que contém a classe FileUtilities. O atributo permite que um assembly chamado Friend1 acesse esse 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 a seguir for compilado em um assembly de nome forte chamado Friend1, ele poderá chamar com êxito o método FileUtilities.AppendDirectorySeparator, mesmo que o método seja interno ao assembly Assembly1. Observe que, se você estiver compilando em C# na linha de comando, deverá usar a opção /out compilador para garantir que o nome do assembly amigo esteja disponível quando o compilador se associar a referências externas.

//
// The assembly that exposes its internal types to this assembly should be
// named Assembly1.dll.
//
// The public key of this assembly should correspond to the public key
// specified in the class constructor of the InternalsVisibleTo attribute in the
// Assembly1 assembly.
//
#using <Assembly1.dll> as_friend

using namespace System;

void main()
{
   String^ dir = L"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.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 a seguir usa o atributo InternalsVisibleToAttribute para tornar um membro internal de um assembly sem sinal visível para outro assembly não assinado. O atributo garante que o método internalStringLib.IsFirstLetterUpperCase em um assembly chamado UtilityLib esteja visível para o código em um assembly chamado Friend2. Veja a seguir o código-fonte para 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

assemblies não assinados

O exemplo a seguir fornece o código-fonte para o assembly Friend2. Observe que, se você estiver compilando em C# na linha de comando, deverá usar a opção /out compilador para garantir que o nome do assembly amigo esteja disponível quando o compilador se associar a referências externas.

#using <UtilityLib.dll> as_friend

using namespace System;
using namespace Utilities::StringUtilities;

void main()
{
   String^ s = "The Sign of the Four";
   Console::WriteLine(StringLib::IsFirstLetterUpperCase(s));
}

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

Comentários

O construtor InternalsVisibleToAttribute define um assembly amigável, que é um assembly que tem acesso aos tipos internos e privados protegidos e membros do assembly atual.

Tanto o assembly atual quanto o assembly amigo devem estar sem sinal ou ambos devem ser assinados com um nome forte. (Para obter mais informações sobre assemblies de nome forte, consulte Criar e usar assemblies de nome forte.) Se ambos não estiverem assinados, o argumento assemblyName consistirá no nome do assembly amigo, especificado sem um caminho de diretório ou extensão de arquivo. Se ambos estiverem assinados, assemblyName consiste no nome do assembly amigo sem seu caminho de diretório ou extensão de nome de arquivo, juntamente com sua chave pública completa (mas não seu token de chave pública). Os outros componentes de um nome forte, como aqueles que fornecem informações de cultura, versão ou arquitetura do processador, não podem ser especificados no argumento assemblyName.

Importante

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 /out compilador. 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 ou -o compilador não deve ser usada ao compilar assemblies amigos com o compilador F#.

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

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

de arquivo desnk_fileSn-p
Exiba a chave pública completa no console:

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

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

de assemblies amigos (C++)
assemblies Friend

Aplica-se a

Partilhar via