InternalsVisibleToAttribute Klasse

Definition

Namespace:

System.Runtime.CompilerServices

Assembly:

System.Runtime.dll

Quelle:

InternalsVisibleToAttribute.cs

Gibt an, dass Typen, die nur innerhalb der aktuellen Assembly sichtbar sind, für eine angegebene Assembly sichtbar sind.

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 attribut InternalsVisibleToAttribute 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 attribut InternalsVisibleToAttribute wird auf die Assembly angewendet, die die FileUtilities Klasse enthält. Mit dem Attribut kann eine Assembly mit dem Namen Friend1 auf dieses interne Element zugreifen.

//
// 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 stark benannte Assembly 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. Wenn Sie in C# über die Befehlszeile kompilieren, müssen Sie die /out Compilerswitch verwenden, 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\

nicht signierte Assemblys

Im folgenden Beispiel wird das attribut InternalsVisibleToAttribute verwendet, um ein internal Mitglied einer nicht signierten Assembly für eine andere nicht signierte Assembly 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 sehen Sie den 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. Wenn Sie in C# über die Befehlszeile kompilieren, müssen Sie die /out Compilerswitch verwenden, 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

Weitere Informationen zu dieser API finden Sie unter Ergänzende API-Hinweise für InternalsVisibleToAttribute.

Konstruktoren

InternalsVisibleToAttribute(String)

Initialisiert eine neue Instanz der InternalsVisibleToAttribute Klasse mit dem Namen der angegebenen Freundassembly.

Eigenschaften

AllInternalsVisible	Diese Eigenschaft ist nicht implementiert.
AssemblyName	Ruft den Namen der Freundassembly ab, für die alle Typen und Typmitglieder, die mit dem Schlüsselwort internal gekennzeichnet sind, sichtbar gemacht werden sollen.
TypeId	Wenn sie in einer abgeleiteten Klasse implementiert wird, wird ein eindeutiger Bezeichner für diese Attribute. (Geerbt von Attribute)

Methoden

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