InternalsVisibleToAttribute Osztály

Definíció

Névtér:

System.Runtime.CompilerServices

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

InternalsVisibleToAttribute.cs

Megadja, hogy a csak az aktuális szerelvényen belül általában látható típusok láthatók legyenek egy adott szerelvényben.

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

Öröklődés

Object

Attribute

InternalsVisibleToAttribute

Attribútumok

AttributeUsageAttribute

Példák

Aláírt szerelvények

Az alábbi példa az InternalsVisibleToAttribute attribútum használatával teszi láthatóvá egy internal aláírt szerelvényben elnevezett AppendDirectorySeparator metódust egy másik aláírt szerelvény számára. Belső metódust tartalmazó osztályt FileUtilitiesAppendDirectorySeparator definiál. Az InternalsVisibleToAttribute attribútum az osztályt tartalmazó FileUtilities szerelvényre lesz alkalmazva. Az attribútum lehetővé teszi, hogy egy elnevezett Friend1 szerelvény hozzáférjen ehhez a belső taghoz.

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

Ha a következő példa egy nevesített szerelvényre Friend1van lefordítva, a Example.Main metódus Friend1 sikeresen meghívható FileUtilities.AppendDirectorySeparator , bár a metódus a Assembly1 szerelvény belső része. Ha a parancssorból C# nyelven készít fordítást, a /out fordítókapcsolóval győződjön meg arról, hogy a barát-szerelvény neve elérhető, amikor a fordító külső hivatkozásokhoz kapcsolódik.

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

Aláíratlan szerelvények

Az alábbi példa az InternalsVisibleToAttribute attribútum használatával teszi láthatóvá egy aláíratlan szerelvény egy internal tagját egy másik aláíratlan szerelvény számára. Az attribútum biztosítja, hogy az internalStringLib.IsFirstLetterUpperCase elnevezett UtilityLib szerelvény metódusa látható legyen a kódban egy nevesített Friend2szerelvényben. A UtilityLib.dllforráskódja a következő:

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

Az alábbi példa a szerelvény forráskódját Friend2 tartalmazza. Vegye figyelembe, hogy ha a parancssorból C#-et készít, a /out fordítókapcsolóval győződjön meg arról, hogy az ismerős szerelvény neve elérhető, amikor a fordító külső hivatkozásokhoz kapcsolódik.

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

Megjegyzések

Az InternalsVisibleToAttribute attribútum azt határozza meg, hogy azok a típusok, amelyek általában csak az aktuális szerelvényen belül láthatók, egy adott szerelvény számára láthatók legyenek.

A C#-ban vagy a Visual Basicben hatókörrel rendelkezőinternal típusok és tagok általában csak abban a szerelvényben láthatók, amelyben definiálva vannak.Friend A hatókörrel rendelkező protected internal típusok és tagok (Protected Friend hatókör a Visual Basic-ben) csak a saját gyűjteményükben vagy az őket tartalmazó osztályból származó típusok számára láthatók. A private protected hatókörrel rendelkező típusok és tagok (Private Protected hatókör a Visual Basic) az adott osztályban vagy az aktuális szerelvényen belül az adott osztályból származó típusokban láthatók.

Az InternalsVisibleToAttribute attribútum ezeket a típusokat és tagokat egy adott szerelvény típusok számára is láthatóvá teszi, amelyet barát-szerelvénynek neveznek. Ez csak a internal (FriendVisual Basicben), (protected internala Visual Basicben) Protected Friendés private protected (Private Protecteda Visual Basicben) tagokra vonatkozik, de nemprivate.

Note

A private protected (Private Protected a Visual Basic-ben) tagok esetében az InternalsVisibleToAttribute attribútum csak a tag tartalmazó osztályából származó típusokra terjeszti ki a hozzáférhetőséget.

Az attribútum a szerelvény szintjén kerül alkalmazásra. Ez azt jelenti, hogy egy forráskódfájl elején, vagy egy Visual Studio-projekt AssemblyInfo fájljában is szerepelhet. Az attribútum segítségével megadhat egyetlen barátszerelvényt, amely hozzáférhet az aktuális szerelvény belső típusaihoz és tagjaihoz. Kétféleképpen definiálhat több barátszerelvényt. Ezek különálló szerelvényszintű attribútumokként is megjelenhetnek, ahogy az alábbi példa is szemlélteti.

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

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

Különálló InternalsVisibleToAttribute címkékkel, de egyetlen assembly kulcsszóval is megjelenhetnek, ahogy azt az alábbi példa szemlélteti.

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

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

A barátszerelvényt a InternalsVisibleToAttribute konstruktor azonosítja. Az aktuális szerelvényt és az ismerős szerelvényt is alá kell írni, vagy mindkét szerelvényt erős névvel kell aláírni.

Ha mindkét szerelvény nincs aláírva, az argumentum az assemblyName ismerős szerelvény nevét tartalmazza, amely címtár-elérési út vagy fájlnévkiterjesztés nélkül van megadva.

Ha mindkét szerelvény erős névvel van aláírva, a InternalsVisibleToAttribute konstruktor argumentumának tartalmaznia kell a könyvtár elérési útja és fájlnévkiterjesztése nélküli szerelvény nevét, valamint a teljes nyilvános kulcsot (és nem a nyilvános kulcs jogkivonatát). Ha egy erős nevű assembly teljes nyilvános kulcsát szeretné lekérni, lásd a teljes nyilvános kulcs lekérése című szakaszt a cikk további részében. További információkért a InternalsVisibleToAttribute erősnevű szerelvényekkel való használatáról lásd a InternalsVisibleToAttribute konstruktort.

Ne adjon meg értékeket az CultureInfoVersionProcessorArchitecture argumentumban, a Visual Basic, a C# és a C++ fordítók ezt fordítóhibaként kezelik. Ha olyan fordítót használ, amely nem tekinti hibának (például az IL Assembler (ILAsm.exe)), és a szerelvények erős nevet viselnek, kivétel keletkezik, amikor a megadott barát szerelvény először hozzáfér az MethodAccessException attribútumot tartalmazó szerelvényhez.

Az attribútum használatáról további információt a Barát szerelvények és a C++ barátszerelvények című témakörben talál.

A teljes nyilvános kulcs lekérése

Az Erős név eszközzel (Sn.exe) lekérheti a teljes nyilvános kulcsot egy erős nevű kulcsfájlból (.snk). Ehhez hajtsa végre a következő lépéseket:

1. Bontsa ki a nyilvános kulcsot az erős nevű kulcsfájlból egy külön fájlba:

   Sn -p <snk_file> <outfile>

2. A teljes nyilvános kulcs megjelenítése a konzolon:

   Sn -tp <outfile>

3. Másolja és illessze be a teljes nyilvános kulcs értékét a forráskódba.

A barátszerelvény fordítása C-vel#

Ha a C#-fordítóval fordítja le a barát-összeállítást, a /out kapcsolóval kifejezetten meg kell adnia a kimeneti fájl nevét (.exe vagy .dll). Erre azért van szükség, mert a fordító még nem hozta létre annak az összetevőnek a nevét, amelyet készít, amikor a külső hivatkozásokhoz való kötés történik. A /out fordító beállítás nem kötelező a Visual Basic fordítóhoz, és a megfelelő -out vagy -o fordító beállítás nem használható az F# fordítóval való fordításkor.

A barát összeszerelés lefordítása C++ használatával

A C++ direktívában az attribútumot InternalsVisibleToAttribute kell használnia, hogy az as_friend attribútum által engedélyezett belső tagok elérhetők legyenek egy barát összeállítás számára. További információért lásd: Barát-összeállítások (C++).

Konstruktorok

Name	Description
InternalsVisibleToAttribute(String)	Inicializálja az InternalsVisibleToAttribute osztály új példányát a megadott barátszerelvény nevével.

Tulajdonságok

Name	Description
AllInternalsVisible	Ez a tulajdonság nincs implementálva.
AssemblyName	Lekéri annak a barátszerelvénynek a nevét, amelynek a kulcsszóval internal megjelölt összes típust és típustagot láthatóvá kell tenni.
TypeId	Ha származtatott osztályban implementálják, ehhez egy egyedi azonosítót Attributekap. (Öröklődés forrása Attribute)

Metódusok

Name	Description
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal. (Öröklődés forrása Attribute)
GetHashCode()	A példány kivonatkódját adja vissza. (Öröklődés forrása Attribute)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
IsDefaultAttribute()	Ha egy származtatott osztályban felül van bírálva, azt jelzi, hogy a példány értéke-e a származtatott osztály alapértelmezett értéke. (Öröklődés forrása Attribute)
Match(Object)	Származtatott osztály felülírásakor egy olyan értéket ad vissza, amely jelzi, hogy ez a példány egy adott objektummal egyenlő-e. (Öröklődés forrása Attribute)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)