InternalsVisibleToAttribute Classe

Definizione

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

Ereditarietà

Object

Attribute

InternalsVisibleToAttribute

Attributi

AttributeUsageAttribute

Esempio

Assembly firmati

Nell'esempio seguente viene utilizzato l'attributo InternalsVisibleToAttribute per rendere visibile un internal metodo denominato AppendDirectorySeparator in un assembly firmato a un altro assembly firmato. Definisce una FileUtilities classe che include un metodo interno AppendDirectorySeparator . L'attributo InternalsVisibleToAttribute viene applicato all'assembly che contiene la FileUtilities classe . 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, il Example.Main metodo in Friend1 può chiamare correttamente il FileUtilities.AppendDirectorySeparator metodo , anche se il metodo è interno all'assembly Assembly1 . 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 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\

Assembly non firmati

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 internalStringLib.IsFirstLetterUpperCase metodo 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

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

Commenti

L'attributo InternalsVisibleToAttribute specifica che i tipi normalmente visibili solo all'interno dell'assembly corrente sono visibili a un assembly specificato.

In genere, i tipi e i membri con internal ambito in C# o Friend ambito in Visual Basic sono visibili solo nell'assembly in cui sono definiti. I tipi e i membri con protected internal ambito (Protected Friend ambito in Visual Basic) sono visibili solo nel proprio assembly o per i tipi che derivano dalla loro classe contenitore. I tipi e i membri con ambito private protected (ambito /Private Protected in Visual Basic) sono visibili nella classe contenitore o nei tipi che derivano dalla classe contenitore all'interno dell'assembly corrente.

L'attributo InternalsVisibleToAttribute rende questi tipi e membri visibili anche ai tipi in un assembly specificato, noto come assembly amico. Ciò si applica solo ai internal membri (Friend in Visual Basic), protected internal(Protected Friend in Visual Basic) e private protected (Private Protected in Visual Basic), ma non private a quelli.

L'attributo viene applicato a livello di assembly. Ciò significa che può essere incluso all'inizio di un file di codice sorgente oppure può essere incluso nel file AssemblyInfo in un progetto di Visual Studio. È possibile usare l'attributo per specificare un singolo assembly amico in grado di accedere ai tipi interni e ai membri dell'assembly corrente. È possibile definire più assembly di amici in due modi. Possono essere visualizzati come singoli attributi a livello di assembly, come illustrato nell'esempio seguente.

[assembly:InternalsVisibleTo("Friend1a")]
[assembly:InternalsVisibleTo("Friend1b")]

<assembly:InternalsVisibleTo("Friend1a")>
<assembly:InternalsVisibleTo("Friend1b")>

Possono anche essere visualizzati con tag separati InternalsVisibleToAttribute , ma una singola assembly parola chiave, come illustrato nell'esempio seguente.

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

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

L'assembly amico viene identificato dal costruttore InternalsVisibleToAttribute. Sia l'assembly corrente che l'assembly amico devono essere entrambi non firmati, oppure entrambi gli assembly devono essere firmati con un nome sicuro.

Se entrambi gli assembly non sono firmati, l'argomento assemblyName è costituito dal nome dell'assembly amico, specificato senza un percorso di directory o l'estensione del nome file.

Se entrambi gli assembly sono firmati con un nome sicuro, l'argomento del InternalsVisibleToAttribute costruttore deve essere costituito dal nome dell'assembly senza il percorso della directory o l'estensione del nome file, insieme alla chiave pubblica completa (e non al token di chiave pubblica). Per ottenere la chiave pubblica completa di un assembly con nome sicuro, vedere la sezione Ottenere la chiave pubblica completa più avanti in questo articolo. Per ulteriori informazioni sull’uso di InternalsVisibleToAttribute con assembly a nome sicuro, vedere InternalsVisibleToAttribute costruttore.

Non includere valori per il campo CultureInfo, Version o ProcessorArchitecture nell'argomento; i compilatori Visual Basic, C# e C++ trattano questo come un errore del compilatore. Se si usa un compilatore che non lo considera come un errore ( ad esempio l'assembler IL (ILAsm.exe)) e gli assembly sono con nome sicuro, viene generata un'eccezione MethodAccessException la prima volta che l'assembly friend specificato accede all'assembly che contiene l'attributo InternalsVisibleToAttribute .

Per altre informazioni su come usare questo attributo, vedere Assembly Friend e assembly Friend C++.

Ottenere la chiave pubblica completa

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

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

   Sn -p <snk_file> <outfile>

2. Visualizzare la chiave pubblica completa nella console:

   Sn -tp <outfile>

3. Copiare e incollare il valore completo della chiave pubblica nel codice sorgente.

Compilare l'assembly friend con C#

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 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#.

Compilare l'assembly Friend con C++

In C++, per rendere i membri interni abilitati dall'attributo InternalsVisibleToAttribute accessibile a un assembly Friend, è necessario usare l'attributo as_friend nella direttiva C++. Per altre informazioni, vedere Assembly Friend (C++).