InternalsVisibleToAttribute(String) Constructor

public:
 InternalsVisibleToAttribute(System::String ^ assemblyName);

public InternalsVisibleToAttribute(string assemblyName);

new System.Runtime.CompilerServices.InternalsVisibleToAttribute : string -> System.Runtime.CompilerServices.InternalsVisibleToAttribute

Public Sub New (assemblyName As String)

Parameters

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 deze de FileUtilities.AppendDirectorySeparator methode aanroepen, ook al is de methode intern voor de Assembly1 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.

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

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

Niet-ondertekende assembly's

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

Opmerkingen

De InternalsVisibleToAttribute constructor definieert een vriendassembly, een assembly die toegang heeft tot de interne en persoonlijke beveiligde typen en leden van de huidige assembly.

Zowel de huidige assembly als de vriendassembly moeten niet ondertekend zijn, of beide moeten worden ondertekend met een sterke naam. (Zie 'Create and use strong-named assembly's' (Sterk benoemde assembly's maken en gebruiken) voor meer informatie over sterk benoemde assembly's.) Als beide niet zijn ondertekend, bestaat het assemblyName argument uit de naam van de vriendassembly, opgegeven zonder mappad of bestandsextensie. Als beide zijn ondertekend, assemblyName bestaat uit de naam van de vriendassembly zonder het mappad of de bestandsnaamextensie, samen met de volledige openbare sleutel (maar niet het token voor de openbare sleutel). De andere onderdelen van een sterke naam, zoals de onderdelen die informatie over cultuur-, versie- of processorarchitectuur bieden, kunnen niet worden opgegeven in het assemblyName argument.

U kunt Sn.exe (Strong Name Tool) 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 -psnk_fileoutfile

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.

Zie de volgende artikelen voor meer informatie over het gebruik van het InternalsVisibleToAttribute kenmerk:

• Vriendenassembly's (C++)

• Vriendenbijeenkomsten