InternalsVisibleToAttribute(String) Constructeur
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Initialise une nouvelle instance de la classe InternalsVisibleToAttribute avec le nom de l’assembly friend spécifié.
public:
InternalsVisibleToAttribute(System::String ^ assemblyName);public InternalsVisibleToAttribute (string assemblyName);new System.Runtime.CompilerServices.InternalsVisibleToAttribute : string -> System.Runtime.CompilerServices.InternalsVisibleToAttributePublic Sub New (assemblyName As String)Paramètres
- assemblyName
- String
Nom d’un assembly ami.
Exemples
assemblys signés
L’exemple suivant utilise l’attribut InternalsVisibleToAttribute pour rendre une méthode internal nommée AppendDirectorySeparator dans un assembly signé visible par un autre assembly signé. Il définit une classe FileUtilities qui inclut une méthode de AppendDirectorySeparator interne. L’attribut InternalsVisibleToAttribute est appliqué à l’assembly qui contient la classe FileUtilities. 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, il peut appeler correctement la méthode FileUtilities.AppendDirectorySeparator, même si la méthode est interne à l’assembly Assembly1. Notez que si vous compilez en C# à partir de la ligne de commande, vous devez utiliser le commutateur /out compilateur pour vous assurer que le nom de l’assembly friend est disponible lorsque le compilateur se lie à des références externes.
//
// 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\
L’exemple suivant utilise l’attribut InternalsVisibleToAttribute pour rendre un membre internal d’un assembly non signé visible par un autre assembly non signé. L’attribut garantit que la méthode internalStringLib.IsFirstLetterUpperCase 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
assemblys non signés
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 /out compilateur pour vous assurer que le nom de l’assembly friend est disponible lorsque le compilateur se lie à des références externes.
#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
Remarques
Le constructeur InternalsVisibleToAttribute définit un assembly friend, qui est un assembly qui a accès aux types et aux membres protégés internes et privés de l’assembly actuel.
L’assembly actuel et l’assembly friend doivent être non signés, ou les deux doivent être signés avec un nom fort. (Pour plus d’informations sur les assemblys avec nom fort, consultez Créer et utiliser des assemblys avec nom fort.) Si les deux sont non 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 fichier. Si les deux sont signés, assemblyName se compose du nom de l’assembly friend sans son chemin d’accès au répertoire ou l’extension de nom de fichier, ainsi que sa clé publique complète (mais pas son jeton de clé publique). Les autres composants d’un nom fort, tels que ceux qui fournissent des informations d’architecture de culture, de version ou de processeur, ne peuvent pas être spécifiés dans l’argument assemblyName.
Important
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 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 compilateur est facultative pour le compilateur Visual Basic, et l’option -out ou -o compilateur correspondante ne doit pas être utilisée lors de la compilation d’assemblys ami avec le compilateur F#.
Vous pouvez utiliser Sn.exe (outil De nom fort) 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 :
Extrayez la clé publique du fichier de clé nommée fort dans un fichier distinct :
Sn -psnk_fileoutfile
Affichez la clé publique complète dans la console :
Sn -tpoutfile
Copiez et collez la valeur de clé publique complète dans votre code source.
Pour plus d’informations sur l’utilisation de l’attribut InternalsVisibleToAttribute, consultez les articles suivants :
S’applique à
Commentaires
Bientôt disponible : Tout au long de l’année 2024, nous abandonnerons progressivement le mécanisme de retour d’information GitHub Issues pour le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez : https://aka.ms/ContentUserFeedback.
Soumettre et afficher des commentaires pour