InternalsVisibleToAttribute Classe

Définition

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

Héritage

Object

Attribute

InternalsVisibleToAttribute

Attributs

AttributeUsageAttribute

Exemples

Assemblys signés

L’exemple suivant utilise l’attribut InternalsVisibleToAttribute pour rendre une internal méthode nommée AppendDirectorySeparator dans un assembly signé visible par un autre assembly signé. Il définit une FileUtilities classe qui inclut une méthode interne AppendDirectorySeparator . L’attribut InternalsVisibleToAttribute est appliqué à l’assembly qui contient la FileUtilities classe. L’attribut permet à un assembly nommé Friend1 d’accéder à ce membre interne.

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

Si l’exemple suivant est compilé dans un assembly nommé fort nommé Friend1, la méthode dans Example.Main laquelle elle Friend1 peut appeler correctement la FileUtilities.AppendDirectorySeparator méthode, bien que la méthode soit interne à l’assemblyAssembly1. Si vous compilez en C# à partir de la ligne de commande, vous devez utiliser le commutateur du compilateur /out pour vous assurer que le nom de l’assembly friend est disponible lorsque le compilateur se lie à des références externes.

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

Assemblys non signés

L’exemple suivant utilise l’attribut InternalsVisibleToAttribute pour rendre un internal membre d’un assembly non signé visible par un autre assembly non signé. L’attribut garantit que la internalStringLib.IsFirstLetterUpperCase méthode dans un assembly nommé UtilityLib est visible par le code d’un assembly nommé Friend2. Voici le code source 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

L’exemple suivant fournit le code source de l’assembly Friend2 . Notez que si vous compilez en C# à partir de la ligne de commande, vous devez utiliser le commutateur du compilateur /out pour vous assurer que le nom de l’assembly friend est disponible lorsque le compilateur se lie à des références externes.

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

Remarques

L’attribut InternalsVisibleToAttribute spécifie que les types qui sont généralement visibles uniquement dans l’assembly actuel sont visibles pour un assembly spécifié.

En règle générale, les types et les membres dont internal l’étendue est en C# ou Friend dans Visual Basic sont visibles uniquement dans l’assembly dans lequel ils sont définis. Les types et les membres avec l'étendue protected internal (étendue Protected Friend dans Visual Basic) sont visibles uniquement dans leur propre assembly ou par les types qui dérivent de leur classe conteneur. Les types et les membres avec private protected étendue (Private Protected étendue dans Visual Basic) sont visibles dans la classe conteneur ou dans les types qui dérivent de leur classe conteneur dans l’assembly actuel.

L’attribut InternalsVisibleToAttribute rend ces types et ces membres également visibles par les types d’un assembly spécifié, appelé assembly friend. Cela s’applique uniquement aux membres internal (Friend en Visual Basic), protected internal (Protected Friend en Visual Basic), et private protected (Private Protected en Visual Basic), mais pas aux membres private.

L’attribut est appliqué au niveau de l’assembly. Cela signifie qu’il peut être inclus au début d’un fichier de code source, ou qu’il peut être inclus dans le fichier AssemblyInfo dans un projet Visual Studio. Vous pouvez utiliser l’attribut pour spécifier un assembly friend unique qui peut accéder aux types internes et aux membres de l’assembly actuel. Vous pouvez définir plusieurs assemblées amies de deux façons. Ils peuvent apparaître en tant qu’attributs individuels au niveau de l’assembly, comme l’illustre l’exemple suivant.

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

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

Ils peuvent également apparaître avec des balises distinctes InternalsVisibleToAttribute , mais un seul assembly mot clé, comme l’illustre l’exemple suivant.

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

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

L'assembly friend est identifié par le constructeur InternalsVisibleToAttribute. L'assembly actuel et l'assembly friend doivent être non signés, ou les deux assemblys doivent être signés avec un nom fort.

Si les deux assemblys ne sont pas signés, l’argument assemblyName se compose du nom de l’assembly friend, spécifié sans chemin d’accès au répertoire ou extension de nom de fichier.

Si les deux assemblys sont signés avec un nom fort, l’argument du InternalsVisibleToAttribute constructeur doit se composer du nom de l’assembly sans son chemin d’accès au répertoire ou l’extension de nom de fichier, ainsi que la clé publique complète (et non son jeton de clé publique). Pour obtenir la clé publique complète d’un assembly avec nom fort, consultez la section Obtenir la clé publique complète plus loin dans cet article. Pour plus d’informations sur l’utilisation de InternalsVisibleToAttribute avec des assemblages à nom fort, consultez le constructeur InternalsVisibleToAttribute.

N’incluez pas de valeurs pour le CultureInfo, Versionou ProcessorArchitecture le champ dans l’argument ; les compilateurs Visual Basic, C# et C++ traitent cela comme une erreur du compilateur. Si vous utilisez un compilateur qui ne le traite pas comme une erreur (par exemple, l’assembleur IL (ILAsm.exe)) et que les assemblies sont à nom fort, une MethodAccessException exception est levée la première fois que l’assembly ami spécifié accède à l’assembly qui contient l’attribut InternalsVisibleToAttribute.

Pour plus d’informations sur l’utilisation de cet attribut, consultez assemblys Friend et assemblys friend C++.

Obtenir la clé publique complète

Vous pouvez utiliser l’outil Strong Name (Sn.exe) pour récupérer la clé publique complète à partir d’un fichier de clé nommée forte (.snk). Pour ce faire, vous effectuez les étapes suivantes :

1. Extrayez la clé publique du fichier de clé avec nom fort dans un fichier distinct :

   Sn -p <snk_file> <outfile>

2. Affichez la clé publique complète dans la console :

   Sn -tp <outfile>

3. Copiez et collez la valeur de clé publique complète dans votre code source.

Compiler l’assembly friend avec C#

Si vous utilisez le compilateur C# pour compiler l’assembly friend, vous devez spécifier explicitement le nom du fichier de sortie (.exe ou .dll) à l’aide de l’option /out du compilateur. Cela est nécessaire, car le compilateur n’a pas encore généré le nom de l’assembly qu’il génère au moment où il est associé à des références externes. L’option /out du compilateur est facultative pour le compilateur Visual Basic, et l’option de compilateur correspondante -out ou -o ne doit pas être utilisée lors de la compilation d'assemblages amis avec le compilateur F#.

Compiler l’assembly friend avec C++

En C++, pour rendre les membres internes activés par l’attribut InternalsVisibleToAttribute accessibles à un assembly ami, il faut utiliser l’attribut as_friend dans la directive C++. Pour plus d’informations, consultez Assemblies amies (C++).