InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute Class

Definition

Gibt an, dass Typen, i. d. R. nur innerhalb der aktuellen Assembly sichtbar sind, auch in einer angegebenen Assembly angezeigt werden können.Specifies that types that are ordinarily visible only within the current assembly are visible to a specified assembly.

public ref class InternalsVisibleToAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true, Inherited=false)]
public sealed class InternalsVisibleToAttribute : Attribute
type InternalsVisibleToAttribute = class
    inherit Attribute
Public NotInheritable Class InternalsVisibleToAttribute
Inherits Attribute
Vererbung
InternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttribute
Attribute

Beispiele

Signierte AssemblysSigned assemblies

Im folgenden Beispiel wird die InternalsVisibleToAttribute Attribut stellen eine internal Methode mit dem Namen AppendDirectorySeparator in eine signierte Assembly in eine andere signierten Assembly sichtbar.The following example uses the InternalsVisibleToAttribute attribute to make an internal method named AppendDirectorySeparator in a signed assembly visible to another signed assembly. Definiert eine FileUtilities -Klasse, einer internen enthält AppendDirectorySeparator Methode.It defines a FileUtilities class that includes an internal AppendDirectorySeparator method. Die InternalsVisibleToAttribute Attribut angewendet wird, auf die Assembly mit der FileUtilities Klasse.The InternalsVisibleToAttribute attribute is applied to the assembly that contains the FileUtilities class. Das Attribut kann eine Assembly namens Friend1 auf diesen internen Member zugreifen.The attribute allows an assembly named Friend1 to access this internal 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 im folgenden Beispiel wird in einer Assembly mit starkem Namen mit dem Namen kompiliert wird Friend1, Example.Main -Methode in der Friend1 kann erfolgreich Aufrufen der FileUtilities.AppendDirectorySeparator -Methode, obwohl die Methode für intern ist die Assembly1 Assembly.If the following example is compiled into a strong-named assembly named Friend1, the Example.Main method in Friend1 can successfully call the FileUtilities.AppendDirectorySeparator method, although the method is internal to the Assembly1 assembly. Beachten Sie, dass wenn Sie in c# über die Befehlszeile kompilieren, müssen Sie verwenden die /out Compilerschalters, um sicherzustellen, dass der Name der Friend-Assembly verfügbar ist, wenn externe Verweise der Compiler bindet.Note that if you are compiling in C# from the command line, you must use the /out compiler switch to ensure that the name of the friend assembly is available when the compiler binds to external references.

//
// 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 AssemblysUnsigned assemblies

Im folgenden Beispiel wird die InternalsVisibleToAttribute Attribut stellen eine internal Mitglied eine unsignierte Assembly sichtbar ist, zu einem anderen nicht signierte Assembly.The following example uses the InternalsVisibleToAttribute attribute to make an internal member of an unsigned assembly visible to another unsigned assembly. Das Attribut stellt sicher, dass die internal StringLib.IsFirstLetterUpperCase Methode in einer Assembly mit dem Namen UtilityLib wird angezeigt, auf den Code in einer Assembly mit dem Namen Friend2.The attribute ensures that the internal StringLib.IsFirstLetterUpperCase method in an assembly named UtilityLib is visible to the code in an assembly named Friend2. Folgendes ist der Quellcode für UtilityLib.dll:The following is the source code for 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

Das folgende Beispiel enthält den Quellcode für die Friend2 Assembly.The following example provides the source code for the Friend2 assembly. Beachten Sie, dass wenn Sie in c# über die Befehlszeile kompilieren, müssen Sie verwenden die /out Compilerschalters, um sicherzustellen, dass der Name der Friend-Assembly verfügbar ist, wenn externe Verweise der Compiler bindet.Note that if you are compiling in C# from the command line, you must use the /out compiler switch to ensure that the name of the friend assembly is available when the compiler binds to external references.

#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 Typen und Member mit internal oder private protected Bereich (in C#) und Friend und Private Protected Gültigkeitsbereich (in Visual Basic) stehen nur in der Assembly, in dem sie definiert sind.Ordinarily, types and members with internal or private protected scope (in C#) and Friend and Private Protected scope (in Visual Basic) are visible only in the assembly in which they are defined. Die InternalsVisibleToAttribute Attribut Weise können sie auch auf die Typen in einer angegebenen Assembly, die als Friend-Assembly bezeichnet wird.The InternalsVisibleToAttribute attribute makes them also visible to the types in a specified assembly, which is known as a friend assembly. Dies gilt nur für internal (Friend in VB) oder private protected(Private Protected in VB) nur Methoden, nicht jedoch private solche.This only applies to internal (Friend in VB) or private protected(Private Protected in VB) methods only, but not private ones.

Das Attribut wird auf Assemblyebene angewendet.The attribute is applied at the assembly level. Dies bedeutet, dass am Anfang einer Quellcodedatei angegeben werden, oder in der AssemblyInfo-Datei in einem Visual Studio-Projekt enthalten sein kann.This means that it can be included at the beginning of a source code file, or it can be included in the AssemblyInfo file in a Visual Studio project. Sie können das Attribut verwenden, um einzelne Friend-Assembly angeben, die internen Typen und Member der aktuellen Assembly zugreifen kann.You can use the attribute to specify a single friend assembly that can access the internal types and members of the current assembly. Sie können mehrere Friend-Assemblys auf zweierlei Weise definieren.You can define multiple friend assemblies in two ways. Sie können als einzelne Attribute auf Assemblyebene, angezeigt werden, wie im folgende Beispiel veranschaulicht.They can appear as individual assembly-level attributes, as the following example illustrates.

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

Sie können auch angezeigt werden mit separaten InternalsVisibleToAttribute Tags, aber ein einzelnes assembly -Schlüsselwort, wie im folgenden Beispiel veranschaulicht.They can also appear with separate InternalsVisibleToAttribute tags but a single assembly keyword, as the following example illustrates.

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

Friend-Assembly wird durch identifiziert die InternalsVisibleToAttribute Konstruktor.The friend assembly is identified by the InternalsVisibleToAttribute constructor. Sowohl die aktuelle Assembly und die Friend-Assembly ohne Vorzeichen sein müssen, oder beide Assemblys müssen mit einem starken Namen signiert werden.Both the current assembly and the friend assembly must be unsigned, or both assemblies must be signed with a strong name.

Wenn beide Assemblys ohne Vorzeichen ist, sind die assemblyName Argument besteht aus dem Namen der Friend-Assembly, ohne die Dateinamenerweiterung für ein Verzeichnis Pfad- oder Dateiname angegeben.If both assemblies are unsigned, the assemblyName argument consists of the name of the friend assembly, specified without a directory path or file name extension.

Wenn beide Assemblys angemeldet sind, mit einem starken Namen, das Argument für die InternalsVisibleToAttribute Konstruktor muss der Name der Assembly ohne dessen Verzeichnis Pfad- oder Dateiname Erweiterung zusammen mit dem vollständigen öffentlichen Schlüssel (und kein Token des öffentlichen Schlüssels) bestehen.If both assemblies are signed with a strong name, the argument to the InternalsVisibleToAttribute constructor must consist of the name of the assembly without its directory path or file name extension, along with the full public key (and not its public key token). Rufen Sie den vollständigen öffentlichen Schlüssel einer Assembly mit starkem Namen finden Sie unter den Abrufen des vollständigen öffentlichen Schlüssels weiter unten in diesem Artikel.To get the full public key of a strong-named assembly, see the Getting the full public key section later in this article. Weitere Informationen zur Verwendung von InternalsVisibleToAttribute mit Assemblys mit starkem Namen finden Sie unter den InternalsVisibleToAttribute Konstruktor.For more information about using InternalsVisibleToAttribute with strong-named assemblies, see the InternalsVisibleToAttribute constructor.

Fügen Sie keine Werte für die CultureInfo, Version, oder ProcessorArchitecture Feld im Argument; die Visual Basic, c# und C++-Compiler, behandeln Sie dies als ein Compilerfehler ausgegeben.Do not include values for the CultureInfo, Version, or ProcessorArchitecture field in the argument; the Visual Basic, C#, and C++ compilers treat this as a compiler error. Wenn Sie einen Compiler verwenden, die nicht als Fehler behandelt (wie z. B. die IL-Assembler (ILAsm.exe)) und die Assemblys mit starkem Namen, eine MethodAccessException Ausnahme ist beim ersten angegebenen Friend-Assembly greift auf die Assembly mit der InternalsVisibleToAttribute Attribut.If you use a compiler that does not treat it as an error (such as the IL Assembler (ILAsm.exe)) and the assemblies are strong-named, a MethodAccessException exception is thrown the first time the specified friend assembly accesses the assembly that contains the InternalsVisibleToAttribute attribute.

Weitere Informationen dazu, wie Sie dieses Attribut verwenden, finden Sie unter den folgenden Themen:For more information about how to use this attribute, see the following topics:

Abrufen des vollständigen öffentlichen SchlüsselsGetting the full public key

Sie können die Strong Name-Tool (Sn.exe) um vollständigen öffentlichen Schlüssels aus einer Datei mit starkem Namen Schlüsseldatei (.snk) abzurufen.You can use the Strong Name Tool (Sn.exe) to retrieve the full public key from a strong-named key (.snk) file. Zu diesem Zweck führen Sie die folgenden Schritte aus:To do this, you perform the following steps:

  1. Extrahieren Sie den öffentlichen Schlüssel aus der Schlüsseldatei mit starkem Namen in einer separaten Datei:Extract the public key from the strong-named key file to a separate file:

    Sn -p snk_file outfileSn -p snk_file outfile

  2. Den vollständigen öffentlichen Schlüssel in der Konsole anzeigen:Display the full public key to the console:

    *Sn - Tp***AusgabedateiSn -tp outfile

  3. Kopieren Sie den vollständigen öffentlichen Schlüssel-Wert in Ihren Quellcode.Copy and paste the full public key value into your source code.

Kompilieren die Friend-Assembly mit c#Compiling the friend assembly with C#

Wenn Sie c#-Compiler verwenden, um die Friend-Assembly zu kompilieren, müssen Sie den Namen der Ausgabedatei (.exe oder .dll) explizit angeben, mit der /out -Compileroption.If you use the C# compiler to compile the friend assembly, you must explicitly specify the name of the output file (.exe or .dll) by using the /out compiler option. 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.This is required because the compiler has not yet generated the name for the assembly it is building at the time it is binding to external references. Die /out Compileroption ist optional für Visual Basic-Compiler, und die entsprechende -out oder - e/a Compileroption sollte nicht verwendet werden, beim Kompilieren von Friend Assemblys mit der F# Compiler.The /out compiler option is optional for the Visual Basic compiler, and the corresponding -out or -o compiler option should not be used when compiling friend assemblies with the F# compiler.

Kompilieren die Friend-Assembly mit C++Compiling the friend assembly with C++

In C++, um die internen Member aktiviert, stellen die InternalsVisibleToAttribute Attribut in einer Friend-Assembly zugegriffen werden kann, müssen Sie die as_friend Attribut in der C++-Anweisung.In C++, in order to make the internal members enabled by the InternalsVisibleToAttribute attribute accessible to a friend assembly, you must use the as_friend attribute in the C++ directive. Weitere Informationen finden Sie unter Friend-Assemblys (C++).For more information, see Friend Assemblies (C++).

Konstruktoren

InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String)

Initialisiert eine neue Instanz der InternalsVisibleToAttribute-Klasse mit dem Namen der angegebenen Friend-Assembly.Initializes a new instance of the InternalsVisibleToAttribute class with the name of the specified friend assembly.

Eigenschaften

AllInternalsVisible AllInternalsVisible AllInternalsVisible AllInternalsVisible

Diese Eigenschaft ist nicht implementiert.This property is not implemented.

AssemblyName AssemblyName AssemblyName 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.Gets the name of the friend assembly to which all types and type members that are marked with the internal keyword are to be made visible.

TypeId TypeId TypeId TypeId

Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from Attribute)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Gibt den Hashcode für diese Instanz zurück.Returns the hash code for this instance.

(Inherited from Attribute)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute()

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Inherited from Attribute)
Match(Object) Match(Object) Match(Object) Match(Object)

Beim Überschreiben in einer abgeleiteten Klasse wird ein Wert zurückgegeben, der angibt, ob diese Instanz einem bestimmten Objekt entspricht.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Inherited from Attribute)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from Attribute)
_Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Gilt für: