InternalsVisibleToAttribute Klasse

Definition

Namespace:

System.Runtime.CompilerServices

Assembly:

System.Runtime.dll

Gibt an, dass Typen, i. d. R. nur innerhalb der aktuellen Assembly sichtbar sind, auch in einer angegebenen Assembly angezeigt werden können.

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

Vererbung

Object

Attribute

InternalsVisibleToAttribute

Attribute

AttributeUsageAttribute

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. Es 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 diesen internen Member.

//
// 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 starkem Namen mit dem Namen Friend1kompiliert wird, kann die Example.Main -Methode in Friend1 die FileUtilities.AppendDirectorySeparator -Methode erfolgreich aufrufen, obwohl die -Methode intern für die Assembly1 Assembly ist. Beachten Sie, dass Sie beim Kompilieren in C# über die Befehlszeile den Compilerschalter /out verwenden müssen, um sicherzustellen, dass der Name der Friend-Assembly verfügbar ist, wenn der Compiler an externe Verweise gebunden wird.

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

Nicht signierte Assemblys

Im folgenden Beispiel wird das InternalsVisibleToAttribute -Attribut verwendet, um einen internal Member einer nicht signierten Assembly 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. Es folgt der Quellcode für 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

Im folgenden Beispiel wird der Quellcode für die Friend2 Assembly bereitgestellt. Beachten Sie, dass Sie beim Kompilieren in C# über die Befehlszeile den Compilerschalter /out verwenden müssen, um sicherzustellen, dass der Name der Friend-Assembly verfügbar ist, wenn der Compiler an externe Verweise gebunden wird.

#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

Normalerweise sind Typen und Member mit internal einem Bereich in C# oder Friend einem Bereich in Visual Basic nur in der Assembly sichtbar, in der sie definiert sind. Typen und Member mit protected internal Bereich (Protected Friend Bereich in Visual Basic) sind nur in ihrer eigenen Assembly oder für Typen sichtbar, die von ihrer enthaltenden Klasse abgeleitet sind. Typen und Member mit private protected Bereich (Private Protected Bereich in Visual Basic) sind in der enthaltenden Klasse oder in Typen sichtbar, die von ihrer enthaltenden Klasse in der aktuellen Assembly abgeleitet sind.

Das InternalsVisibleToAttribute Attribut macht diese Typen und Member auch für die Typen in einer angegebenen Assembly sichtbar, die als Friend-Assembly bezeichnet wird. Dies gilt nur internal für (Friend in Visual Basic), protected internal(Protected Friend in Visual Basic) und private protected (Private Protected in Visual Basic) Member, aber nicht private für elemente.

Hinweis

Im Fall von private protected (Private Protected in Visual Basic) Membern erweitert das Attribut den InternalsVisibleToAttribute Zugriff nur auf Typen, die von der enthaltenden Klasse des Members abgeleitet sind.

Das Attribut wird auf Assemblyebene angewendet. Dies bedeutet, dass es am Anfang einer Quellcodedatei oder in der AssemblyInfo-Datei in einem Visual Studio-Projekt enthalten sein kann. Sie können das -Attribut verwenden, um eine einzelne Friend-Assembly anzugeben, die auf die internen Typen und Member der aktuellen Assembly zugreifen kann. Sie können mehrere Friend-Assemblys auf zwei Arten definieren. Sie können als einzelne Attribute auf Assemblyebene angezeigt werden, wie im folgenden Beispiel veranschaulicht.

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

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

Sie können auch mit separaten InternalsVisibleToAttribute Tags, aber einem einzelnen assembly Schlüsselwort angezeigt werden, wie im folgenden Beispiel veranschaulicht.

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

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

Die Friend-Assembly wird vom InternalsVisibleToAttribute Konstruktor identifiziert. Sowohl die aktuelle Assembly als auch die Friend-Assembly müssen nicht signiert sein, oder beide Assemblys müssen mit einem starken Namen signiert sein.

Wenn beide Assemblys nicht signiert sind, besteht das assemblyName Argument aus dem Namen der Friend-Assembly, angegeben ohne Verzeichnispfad oder Dateinamenerweiterung.

Wenn beide Assemblys mit einem starken Namen signiert sind, muss das Argument für den InternalsVisibleToAttribute Konstruktor aus dem Namen der Assembly ohne Verzeichnispfad oder Dateinamenerweiterung zusammen mit dem vollständigen öffentlichen Schlüssel (und nicht dem Token für öffentliche Schlüssel) bestehen. Informationen zum Abrufen des vollständigen öffentlichen Schlüssels einer Assembly mit starkem Namen finden Sie im Abschnitt Abrufen des vollständigen öffentlichen Schlüssels weiter unten in diesem Artikel. Weitere Informationen zur Verwendung InternalsVisibleToAttribute mit Assemblys mit starkem Namen finden Sie im InternalsVisibleToAttribute Konstruktor.

Schließen Sie keine Werte für das CultureInfoFeld , Versionoder ProcessorArchitecture in das Argument ein. Die Visual Basic-, C#- und C++-Compiler behandeln dies als Compilerfehler. Wenn Sie einen Compiler verwenden, der ihn nicht als Fehler behandelt (z. B. il Assembler (ILAsm.exe)), und die Assemblys mit starkem Namen benannt sind, wird eine MethodAccessException Ausnahme ausgelöst, wenn die angegebene Friend-Assembly zum ersten Mal auf die Assembly zugreift, die das InternalsVisibleToAttribute Attribut enthält.

Weitere Informationen zur Verwendung dieses Attributs finden Sie unter Friend-Assemblys und C++-Friend-Assemblys.

Abrufen des vollständigen öffentlichen Schlüssels

Sie können das Strong Name Tool (Sn.exe) verwenden, um den vollständigen öffentlichen Schlüssel aus einer Datei mit starkem Namen (.snk) abzurufen. Führen Sie dazu die folgenden Schritte aus:

1. Extrahieren Sie den öffentlichen Schlüssel aus der Schlüsseldatei mit starkem Namen in eine separate Datei:

   Sn -psnk_fileOutfile

2. Zeigen Sie den vollständigen öffentlichen Schlüssel für die Konsole an:

   Sn -tpoutfile

3. Kopieren Sie den vollständigen Öffentlichen Schlüsselwert, und fügen Sie ihn in Ihren Quellcode ein.

Kompilieren der Friend-Assembly mit C #

Wenn Sie den C#-Compiler zum Kompilieren der Friend-Assembly verwenden, müssen Sie den Namen der Ausgabedatei (.exe oder .dll) mithilfe der Compileroption /out explizit angeben. 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.

Kompilieren der Friend-Assembly mit C++

Um die durch das InternalsVisibleToAttribute Attribut aktivierten internen Member in C++ für eine Friend-Assembly zugänglich zu machen, müssen Sie das as_friend -Attribut in der C++-Direktive verwenden. Weitere Informationen finden Sie unter Friend Assemblies (C++).

Konstruktoren

InternalsVisibleToAttribute(String)

Initialisiert eine neue Instanz der InternalsVisibleToAttribute-Klasse mit dem Namen der angegebenen Friend-Assembly.

Eigenschaften

AllInternalsVisible	Diese Eigenschaft ist nicht implementiert.
AssemblyName	Ruft den Namen der Friend-Assembly ab, für die alle mit dem Schlüsselwort internal gekennzeichneten Typen und Typmember sichtbar gemacht werden sollen.
TypeId	Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab. (Geerbt von Attribute)

Methoden

Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Geerbt von Attribute)
GetHashCode()	Gibt den Hashcode für diese Instanz zurück. (Geerbt von Attribute)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
IsDefaultAttribute()	Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist. (Geerbt von Attribute)
Match(Object)	Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert zurückgegeben, der angibt, ob diese Instanz einem bestimmten Objekt entspricht. (Geerbt von Attribute)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)