InternalsVisibleToAttribute(String) Costruttore

Riferimento

Definizione

Spazio dei nomi:: System.Runtime.CompilerServices

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origine:: InternalsVisibleToAttribute.cs

Origine:: InternalsVisibleToAttribute.cs

Origine:: InternalsVisibleToAttribute.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Inizializza una nuova istanza della classe InternalsVisibleToAttribute con il nome dell'assembly Friend specificato.

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)

Parametri

assemblyName: String

Nome di un assembly friend.

Esempio

assembly firmati

Nell'esempio seguente viene utilizzato l'attributo InternalsVisibleToAttribute per rendere visibile un metodo internal denominato AppendDirectorySeparator in un assembly firmato a un altro assembly firmato. Definisce una classe FileUtilities che include un metodo AppendDirectorySeparator interno. L'attributo InternalsVisibleToAttribute viene applicato all'assembly che contiene la classe FileUtilities. L'attributo consente a un assembly denominato Friend1 di accedere a questo 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 l'esempio seguente viene compilato in un assembly con nome sicuro denominato Friend1, può chiamare correttamente il metodo FileUtilities.AppendDirectorySeparator, anche se il metodo è interno all'assembly Assembly1. Si noti che se si esegue la compilazione in C# dalla riga di comando, è necessario usare l'opzione del compilatore /out per assicurarsi che il nome dell'assembly Friend sia disponibile quando il compilatore viene associato a riferimenti esterni.

//
// 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\

Nell'esempio seguente viene utilizzato l'attributo InternalsVisibleToAttribute per rendere visibile un internal membro di un assembly senza segno a un altro assembly senza segno. L'attributo garantisce che il metodo internalStringLib.IsFirstLetterUpperCase in un assembly denominato UtilityLib sia visibile al codice in un assembly denominato Friend2. Di seguito è riportato il codice sorgente per 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

assembly non firmati

Nell'esempio seguente viene fornito il codice sorgente per l'assembly Friend2. Si noti che se si esegue la compilazione in C# dalla riga di comando, è necessario usare l'opzione del compilatore /out per assicurarsi che il nome dell'assembly Friend sia disponibile quando il compilatore viene associato a riferimenti esterni.

#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

Commenti

Il costruttore InternalsVisibleToAttribute definisce un assembly friend, ovvero un assembly che ha accesso ai tipi e ai membri protetti interni e privati dell'assembly corrente.

Sia l'assembly corrente che l'assembly friend devono essere senza segno oppure entrambi devono essere firmati con un nome sicuro. Per altre informazioni sugli assembly con nome sicuro, vedere Creare e usare assembly con nome sicuro. Se entrambi non sono firmati, l'argomento assemblyName è costituito dal nome dell'assembly friend, specificato senza un percorso di directory o un'estensione di file. Se entrambi sono firmati, assemblyName è costituito dal nome dell'assembly friend senza il percorso di directory o l'estensione del nome file, insieme alla chiave pubblica completa (ma non al token di chiave pubblica). Gli altri componenti di un nome sicuro, ad esempio quelli che forniscono impostazioni cultura, versione o informazioni sull'architettura del processore, non possono essere specificati nell'argomento assemblyName.

Importante

Se si usa il compilatore C# per compilare l'assembly Friend, è necessario specificare in modo esplicito il nome del file di output (.exe o .dll) usando l'opzione del compilatore /out. Questa operazione è necessaria perché il compilatore non ha ancora generato il nome per l'assembly che sta compilando al momento dell'associazione a riferimenti esterni. L'opzione del compilatore /out è facoltativa per il compilatore di Visual Basic e l'opzione del compilatore - out o -o corrispondente non deve essere usata durante la compilazione di assembly Friend con il compilatore F#.

È possibile usare Sn.exe (strumento nome sicuro) per recuperare la chiave pubblica completa da un file di chiave con nome sicuro (con estensione snk). A tale scopo, seguire questa procedura:

Estrarre la chiave pubblica dal file di chiave con nome sicuro in un file separato:

sn -psnk_file outfile
Visualizzare la chiave pubblica completa nella console:

sn -tp outfile
Copiare e incollare il valore completo della chiave pubblica nel codice sorgente.

Per altre informazioni su come usare l'attributo InternalsVisibleToAttribute, vedere gli articoli seguenti:

assembly Friend (C++)
assembly Friend

Si applica a

Condividi tramite