InternalsVisibleToAttribute Klas

Definitie

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

Overname

Object

Attribute

InternalsVisibleToAttribute

Kenmerken

AttributeUsageAttribute

Voorbeelden

Ondertekende assembly's

In het volgende voorbeeld wordt het InternalsVisibleToAttribute kenmerk gebruikt om een internal methode met de naam AppendDirectorySeparator in een ondertekende assembly zichtbaar te maken voor een andere ondertekende assembly. Hiermee wordt een FileUtilities klasse gedefinieerd die een interne AppendDirectorySeparator methode bevat. Het InternalsVisibleToAttribute kenmerk wordt toegepast op de assembly die de FileUtilities klasse bevat. Met het kenmerk kan een assembly met de naam Friend1 toegang krijgen tot dit interne lid.

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

Als het volgende voorbeeld wordt gecompileerd in een sterk benoemde assembly met de naam Friend1, kan de Example.Main methode in Friend1 de FileUtilities.AppendDirectorySeparator methode worden aangeroepen, hoewel de methode intern is voor de Assembly1 assembly. Als u vanuit de opdrachtregel in C# compileert, moet u de schakeloptie /out compiler gebruiken om ervoor te zorgen dat de naam van de vriend-assembly beschikbaar is wanneer de compiler verbinding maakt met externe verwijzingen.

//
// 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 = FileUtilities1.AppendDirectorySeparator(dir)
        Console.WriteLine(dir)
   End Sub
End Module
' The example displays the following output:
'       C:\Program Files\

Niet-ondertekende assembly's

In het volgende voorbeeld wordt het InternalsVisibleToAttribute kenmerk gebruikt om een internal lid van een niet-ondertekende assembly zichtbaar te maken voor een andere niet-ondertekende assembly. Het kenmerk zorgt ervoor dat de methode in een assembly met de internalStringLib.IsFirstLetterUpperCase naam UtilityLib zichtbaar is voor de code in een assembly met de naam Friend2. Hier volgt de broncode voor 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

Het volgende voorbeeld bevat de broncode voor de Friend2 assembly. Als u in C# vanaf de opdrachtregel compileert, moet u de schakeloptie /out compiler gebruiken om ervoor te zorgen dat de naam van de vriendassembly beschikbaar is wanneer de compiler verbinding maakt met externe verwijzingen.

using System;

public class Example1
{
   public static void Main()
   {
      String s = "The Sign of the Four";
      //Console.WriteLine(Utilities.StringUtilities.StringLib.IsFirstLetterUpperCase(s));
   }
}

Module Example1
    Public Sub Main()
        Dim s As String = "The Sign of the Four"
        ' Console.WriteLine(Utilities.StringUtilities.StringLib.IsFirstLetterUpperCase(s))
    End Sub
End Module

Opmerkingen

Het InternalsVisibleToAttribute kenmerk geeft aan dat typen die normaal gesproken alleen zichtbaar zijn binnen de huidige assembly, zichtbaar zijn voor een opgegeven assembly.

Normaal gesproken zijn typen en leden met internal een bereik in C# of Friend bereik in Visual Basic alleen zichtbaar in de assembly waarin ze zijn gedefinieerd. Typen en leden met protected internal bereik (Protected Friend bereik in Visual Basic) zijn alleen zichtbaar in hun eigen assembly of voor typen die zijn afgeleid van hun omhullende klasse. Typen en leden met private protected bereik (Private Protected bereik in Visual Basic) zijn zichtbaar in de betreffende klasse of in typen die zijn afgeleid van hun klasse in de huidige assembly.

Het InternalsVisibleToAttribute kenmerk maakt deze typen en leden ook zichtbaar voor de typen in een opgegeven assembly, die ook wel een vriendassembly wordt genoemd. Dit geldt alleen voor internal (Friend in Visual Basic), protected internal (Protected Friend in Visual Basic) en private protected (Private Protected in Visual Basic) leden, maar niet voor private leden.

Het kenmerk wordt toegepast op assemblyniveau. Dit betekent dat het kan worden opgenomen aan het begin van een broncodebestand of kan worden opgenomen in het AssemblyInfo-bestand in een Visual Studio-project. U kunt het kenmerk gebruiken om één vriendassembly op te geven die toegang heeft tot de interne typen en leden van de huidige assembly. U kunt twee manieren gebruiken om meerdere vriendensamenstellingen te definiëren. Ze kunnen worden weergegeven als afzonderlijke kenmerken op assemblyniveau, zoals in het volgende voorbeeld wordt geïllustreerd.

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

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

Ze kunnen ook worden weergegeven met afzonderlijke InternalsVisibleToAttribute tags, maar één assembly trefwoord, zoals in het volgende voorbeeld wordt geïllustreerd.

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

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

De vriend-assembly wordt geïdentificeerd door de InternalsVisibleToAttribute constructor. Zowel de huidige assembly als de vriendelijke assembly moeten ongemarkeerd zijn, of beide assembly's moeten worden ondertekend met een sterke naam.

Als beide assembly's niet zijn ondertekend, bestaat het assemblyName argument uit de naam van de vriendassembly, opgegeven zonder mappad of bestandsnaamextensie.

Als beide assembly's zijn ondertekend met een sterke naam, moet het argument voor de InternalsVisibleToAttribute constructor bestaan uit de naam van de assembly zonder het mappad of de bestandsnaamextensie, samen met de volledige openbare sleutel (en niet het bijbehorende openbare-sleuteltoken). Als u de volledige openbare sleutel van een sterk benoemde assembly wilt ophalen, raadpleegt u de Sectie 'Volledige openbare sleutel ophalen' verderop in dit artikel. Zie de InternalsVisibleToAttribute constructor voor meer informatie over het gebruik van InternalsVisibleToAttribute met strong-named assemblies.

Neem geen waarden op voor de CultureInfo, Versionof ProcessorArchitecture het veld in het argument; de Visual Basic-, C#- en C++-compilers behandelen dit als een compilerfout. Als u een compiler gebruikt die deze niet als een fout behandelt (zoals de IL Assemblyer (ILAsm.exe)) en de assembly's een sterke naam hebben, wordt er een MethodAccessException uitzondering gegenereerd wanneer de opgegeven vriend-assembly voor het eerst toegang krijgt tot de assembly die het InternalsVisibleToAttribute kenmerk bevat.

Zie Vriendenassembly's en C++-vriendenassembly's voor meer informatie over het gebruik van dit kenmerk.

De volledige openbare sleutel ophalen

U kunt het hulpprogramma Sterke naam (Sn.exe) gebruiken om de volledige openbare sleutel op te halen uit een bestand met een sterke naam (.snk). Hiervoor voert u de volgende stappen uit:

1. Pak de openbare sleutel uit het sterk benoemde sleutelbestand uit naar een afzonderlijk bestand:

   Sn -p <snk_file> <outfile>

2. De volledige openbare sleutel weergeven in de console:

   Sn -tp <outfile>

3. Kopieer en plak de volledige waarde van de openbare sleutel in uw broncode.

Compileer de vriendassembly met C#

Als u de C#-compiler gebruikt om de vriendassembly te compileren, moet u expliciet de naam van het uitvoerbestand (.exe of .dll) opgeven met behulp van de optie /out compiler. Dit is vereist omdat de compiler nog niet de naam heeft gegenereerd voor de assembly die het bouwt op het moment dat deze is gebonden aan externe verwijzingen. De compileroptie /out is optioneel voor de Visual Basic-compiler en de bijbehorende -out of -o compileroptie mag niet worden gebruikt bij het compileren van vriendassemblies met de F#-compiler.

Compileer de assembly van een vriend met C++

In C++ moet u het InternalsVisibleToAttribute kenmerk in de C++-instructie gebruiken om de interne leden, die worden ingeschakeld door het as_friend kenmerk, toegankelijk te maken voor een vriendassembly. Zie Friend Assemblies (C++) voor meer informatie.