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 à l'aide du 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 friend.
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 pour un autre assembly signé. Elle 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, il peut appeler correctement la FileUtilities.AppendDirectorySeparator méthode, 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 du compilateur /out pour vous assurer que le nom de l’assembly friend est disponible lorsque le compilateur est lié à 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 internal membre d’un assembly non signé visible pour un autre assembly non signé. L’attribut garantit que la internalStringLib.IsFirstLetterUpperCase méthode dans un assembly nommé UtilityLib est visible par le code dans un assembly nommé Friend2. Voici le code source pour 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 du compilateur /out pour vous assurer que le nom de l’assembly friend est disponible lorsque le compilateur est lié à 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 InternalsVisibleToAttribute constructeur définit un assembly friend, qui est un assembly qui a accès aux types et 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 à nom fort, consultez Create et utiliser des assemblys à nom fort.) Si les deux 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 fichier. Si les deux sont signés, assemblyName se compose du nom de l’assembly friend sans son chemin d’accès de répertoire ou extension de nom de fichier, ainsi que de sa clé publique complète (mais pas de son jeton de clé publique). Les autres composants d’un nom fort, tels que ceux qui fournissent des informations sur la culture, la version ou l’architecture du 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 de compilateur /out . Ceci est nécessaire, car le compilateur n’a pas encore généré le nom de l’assembly qu’il est en train de créer au moment où il effectue une liaison avec les références externes. L’option de compilateur /out est facultative pour le compilateur Visual Basic, et l’option de compilateur -out ou -o correspondante ne doit pas être utilisée lors de la compilation d’assemblys friend avec le compilateur F#.
Vous pouvez utiliser Sn.exe (outil Strong Name) pour récupérer la clé publique complète à partir d’un fichier de clé avec nom fort (.snk). Pour ce faire, procédez comme suit :
Extrayez la clé publique du fichier de clé avec nom 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 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour