InternalsVisibleToAttribute(String) Konstruktor
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Initialisiert eine neue Instanz der InternalsVisibleToAttribute-Klasse mit dem Namen der angegebenen Friend-Assembly.
public:
InternalsVisibleToAttribute(System::String ^ assemblyName);public InternalsVisibleToAttribute (string assemblyName);new System.Runtime.CompilerServices.InternalsVisibleToAttribute : string -> System.Runtime.CompilerServices.InternalsVisibleToAttributePublic Sub New (assemblyName As String)Parameter
- assemblyName
- String
Der Name einer Friend-Assembly.
Beispiele
Signierte Assemblys
Im folgenden Beispiel wird das InternalsVisibleToAttribute -Attribut verwendet, um eine internal Methode namens AppendDirectorySeparator in einer signierten Assembly für eine andere signierte Assembly sichtbar zu machen. Sie definiert eine FileUtilities Klasse, die eine interne AppendDirectorySeparator Methode enthält. Das InternalsVisibleToAttribute Attribut wird auf die Assembly angewendet, die die FileUtilities -Klasse enthält. Das Attribut ermöglicht einer Assembly namens Friend1 den Zugriff auf dieses interne Element.
//
// 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
Wenn das folgende Beispiel in eine Assembly mit Friend1starkem Namen kompiliert wird, kann die FileUtilities.AppendDirectorySeparator Methode erfolgreich aufgerufen werden, auch wenn die Methode intern in der Assembly1 Assembly ist. Beachten Sie, dass Sie beim Kompilieren in C# über die Befehlszeile die Compileroption /out verwenden müssen, um sicherzustellen, dass der Name der Friend-Assembly verfügbar ist, wenn der Compiler an externe Verweise bindet.
//
// 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\
Im folgenden Beispiel wird das InternalsVisibleToAttribute -Attribut verwendet, um ein internal Element einer assembly ohne Vorzeichen für eine andere Assembly ohne Vorzeichen sichtbar zu machen. Das -Attribut stellt sicher, dass die internalStringLib.IsFirstLetterUpperCase -Methode in einer Assembly mit dem Namen UtilityLib für den Code in einer Assembly mit dem Namen Friend2sichtbar ist. Im Folgenden wird der Quellcode für UtilityLib.dll angezeigt:
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 ohne Vorzeichen
Im folgenden Beispiel wird der Quellcode für die Friend2 Assembly bereitgestellt. Beachten Sie, dass Sie beim Kompilieren in C# über die Befehlszeile die Compileroption /out verwenden müssen, um sicherzustellen, dass der Name der Friend-Assembly verfügbar ist, wenn der Compiler an externe Verweise bindet.
#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
Hinweise
Der InternalsVisibleToAttribute Konstruktor definiert eine Friendassembly, bei der es sich um eine Assembly handelt, die Zugriff auf die internen und privaten geschützten Typen und Member der aktuellen Assembly hat.
Sowohl die aktuelle Assembly als auch die Friend-Assembly müssen nicht signiert sein, oder beide müssen mit einem starken Namen signiert werden. (Weitere Informationen zu Assemblys mit starkem Namen finden Sie unter Create und Verwenden von Assemblys mit starkem Namen.) Wenn beide nicht signiert sind, besteht das assemblyName Argument aus dem Namen der Freundesassembly, der ohne Verzeichnispfad oder Dateierweiterung angegeben wird. Wenn beide signiert sind, assemblyName besteht aus dem Namen der Freundesassembly ohne ihren Verzeichnispfad oder die Dateinamenerweiterung zusammen mit dem vollständigen öffentlichen Schlüssel (aber nicht dem Token für den öffentlichen Schlüssel). Die anderen Komponenten eines starken Namens, z. B. solche, die Kultur-, Versions- oder Prozessorarchitekturinformationen bereitstellen, können im assemblyName Argument nicht angegeben werden.
Wichtig
Wenn Sie den C#-Compiler verwenden, um die Friend-Assembly zu kompilieren, müssen Sie den Namen der Ausgabedatei (.exe oder .dll) explizit angeben, indem Sie die Compileroption /out verwenden. Dies ist erforderlich, da der Compiler den Namen für die Assembly, die er erstellt, noch nicht generiert hat, wenn er Bindungen an externe Referenzen vornimmt. Die Compileroption /out ist für den Visual Basic-Compiler optional, und die entsprechende Compileroption -out oder -o sollte beim Kompilieren von Friend-Assemblys mit dem F#-Compiler nicht verwendet werden.
Sie können Sn.exe (Strong Name Tool) verwenden, um den vollständigen öffentlichen Schlüssel aus einer Datei mit starkem Namen (.snk) abzurufen. Führen Sie hierzu die folgenden Schritte aus:
Extrahieren Sie den öffentlichen Schlüssel aus der Datei mit starkem Namen in eine separate Datei:
Sn -psnk_fileOutfile
Zeigen Sie den vollständigen öffentlichen Schlüssel für die Konsole an:
Sn -tpoutfile
Kopieren Sie den vollständigen Wert des öffentlichen Schlüssels, und fügen Sie ihn in Ihren Quellcode ein.
Weitere Informationen zur Verwendung des InternalsVisibleToAttribute Attributs finden Sie in den folgenden Artikeln:
Gilt für:
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für