InternalsVisibleToAttribute Klasa

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Runtime.CompilerServices
Zestaw:
System.Runtime.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Określa, że typy, które są zwykle widoczne tylko w bieżącym zestawie są widoczne dla określonego zestawu.

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
Dziedziczenie
Object
Attribute
InternalsVisibleToAttribute
Atrybuty
AttributeUsageAttribute

Przykłady

Podpisane zestawy

W poniższym przykładzie użyto atrybutu InternalsVisibleToAttribute do utworzenia internal metody o nazwie AppendDirectorySeparator w podpisanym zestawie widocznym dla innego podpisanego zestawu. Definiuje klasę FileUtilities , która zawiera metodę wewnętrzną AppendDirectorySeparator . Atrybut InternalsVisibleToAttribute jest stosowany do zestawu, który zawiera klasę FileUtilities . Atrybut umożliwia zestawowi o nazwie Friend1 dostęp do tego wewnętrznego elementu członkowskiego.

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

Jeśli poniższy przykład jest kompilowany w zestawie o silnej nazwie o nazwie Friend1, Example.Main metoda w Friend1 pliku może pomyślnie wywołać metodę FileUtilities.AppendDirectorySeparator , chociaż metoda jest wewnętrzna dla Assembly1 zestawu. Pamiętaj, że w przypadku kompilowania w języku C# z wiersza polecenia należy użyć przełącznika kompilatora /out , aby upewnić się, że nazwa zestawu zaprzyjaźnionego jest dostępna, gdy kompilator wiąże się z odwołaniami zewnętrznymi.

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

Zestawy niepodpisane

W poniższym przykładzie użyto atrybutu InternalsVisibleToAttribute , aby element internal członkowski niepodpisanego zestawu był widoczny dla innego niepodpisanego zestawu. Atrybut zapewnia, że internal StringLib.IsFirstLetterUpperCase metoda w zestawie o nazwie UtilityLib jest widoczna dla kodu w zestawie o nazwie Friend2. Poniżej przedstawiono kod źródłowy 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

Poniższy przykład zawiera kod źródłowy zestawu Friend2 . Pamiętaj, że w przypadku kompilowania w języku C# z wiersza polecenia należy użyć przełącznika kompilatora /out , aby upewnić się, że nazwa zestawu zaprzyjaźnionego jest dostępna, gdy kompilator wiąże się z odwołaniami zewnętrznymi.

#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

Uwagi

Zwykle typy i elementy członkowskie z zakreseminternal w języku C# lub Friend zakres w Visual Basic są widoczne tylko w zestawie, w którym są zdefiniowane. Typy i składowe z zakresem protected internal (Protected Friend zakres w Visual Basic) są widoczne tylko w ich własnym zestawie lub typach, które pochodzą z ich zawierającej klasę. Typy i składowe z zakresem private protected (Private Protected zakres w Visual Basic) są widoczne w zawierającej klasy lub w typach, które pochodzą z ich zawierającej klasę w bieżącym zestawie

Atrybut InternalsVisibleToAttribute sprawia, że te typy i elementy członkowskie są również widoczne dla typów w określonym zestawie, który jest znany jako zestaw zaprzyjaźniony. Dotyczy to tylko internal elementów członkowskich (Friend w Visual Basic), protected internal(Protected Friend w Visual Basic) i private protected (Private Protected w Visual Basic), ale nie private tych.

Uwaga

W przypadku private protected elementów członkowskich (Private Protected w Visual Basic) InternalsVisibleToAttribute atrybut rozszerza ułatwienia dostępu tylko do typów, które pochodzą z zawierającej klasy składowej.

Atrybut jest stosowany na poziomie zestawu. Oznacza to, że może on zostać uwzględniony na początku pliku kodu źródłowego lub może zostać uwzględniony w pliku AssemblyInfo w projekcie Visual Studio. Można użyć atrybutu , aby określić jeden zestaw zaprzyjaźniony, który może uzyskać dostęp do typów wewnętrznych i składowych bieżącego zestawu. Można zdefiniować wiele przyjaznych zestawów na dwa sposoby. Mogą być wyświetlane jako poszczególne atrybuty na poziomie zestawu, jak pokazano w poniższym przykładzie.

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

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

Mogą również być wyświetlane z oddzielnymi InternalsVisibleToAttribute tagami, ale pojedynczym assembly słowem kluczowym, jak pokazano w poniższym przykładzie.

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

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

Zestaw zaprzyjaźniony jest identyfikowany przez InternalsVisibleToAttribute konstruktora. Zarówno obecny zestaw, jak i zestaw zaprzyjaźniony muszą być niepodpisane lub oba zestawy muszą być podpisane silną nazwą.

Jeśli oba zestawy są niepodpisane, assemblyName argument składa się z nazwy zestawu zaprzyjaźnionego, określonego bez ścieżki katalogu lub rozszerzenia nazwy pliku.

Jeśli oba zestawy są podpisane za pomocą silnej nazwy, argument InternalsVisibleToAttribute konstruktora musi składać się z nazwy zestawu bez ścieżki katalogu lub rozszerzenia nazwy pliku wraz z pełnym kluczem publicznym (a nie tokenem klucza publicznego). Aby uzyskać pełny klucz publiczny zestawu o silnej nazwie, zobacz sekcję Pobieranie pełnego klucza publicznego w dalszej części tego artykułu. Aby uzyskać więcej informacji na temat używania z InternalsVisibleToAttribute zestawami o silnych nazwach, zobacz InternalsVisibleToAttribute konstruktor.

Nie dołączaj wartości dla CultureInfopola , Versionlub ProcessorArchitecture w argumencie; kompilatory Visual Basic, C# i C++ traktują to jako błąd kompilatora. Jeśli używasz kompilatora, który nie traktuje go jako błędu (takiego jak asembler IL (ILAsm.exe)), a zestawy są silnie nazwane, MethodAccessException wyjątek jest zgłaszany po raz pierwszy, gdy określony zestaw zaprzyjaźniony uzyskuje dostęp do zestawu zawierającego InternalsVisibleToAttribute atrybut .

Aby uzyskać więcej informacji na temat używania tego atrybutu, zobacz Friend assemblies and C++ friend assemblies (Zestawy znajome języka C++).

Pobieranie pełnego klucza publicznego

Za pomocą narzędzia strong name tool (Sn.exe) można pobrać pełny klucz publiczny z pliku klucza o silnych nazwach (snk). W tym celu należy wykonać następujące czynności:

  1. Wyodrębnij klucz publiczny z pliku klucza o silnej nazwie do oddzielnego pliku:

    Sn -p snk_file plik outfile

  2. Wyświetl pełny klucz publiczny w konsoli:

    Sn - tpoutfile

  3. Skopiuj i wklej pełną wartość klucza publicznego do kodu źródłowego.

Kompilowanie zestawu zaprzyjaźnionego za pomocą języka C

Jeśli kompilator języka C# jest używany do kompilowania zestawu zaprzyjaźnionego, należy jawnie określić nazwę pliku wyjściowego (.exe lub .dll) przy użyciu opcji /out kompilatora. Jest to wymagane, ponieważ kompilator nie wygenerował jeszcze nazwy zestawu, który kompiluje w momencie powiązania z odwołaniami zewnętrznymi. Opcja /out kompilatora jest opcjonalna dla kompilatora Visual Basic, a odpowiednia opcja kompilatora -out lub -o nie powinna być używana podczas kompilowania przyjaznych zestawów za pomocą kompilatora języka F#.

Kompilowanie przyjaznego zestawu przy użyciu języka C++

W języku C++, aby umożliwić członkom wewnętrznym włączenie przez InternalsVisibleToAttribute atrybut dostępny dla zestawu zaprzyjaźnionego, należy użyć atrybutu as_friend w dyrektywie C++. Aby uzyskać więcej informacji, zobacz Friend Assemblies (C++).

Konstruktory

InternalsVisibleToAttribute(String)

Inicjuje InternalsVisibleToAttribute nowe wystąpienie klasy o nazwie określonego zestawu zaprzyjaźnionego.

Właściwości

AllInternalsVisible

Ta właściwość nie jest zaimplementowana.
AssemblyName

Pobiera nazwę zestawu zaprzyjaźnionego, do którego mają być widoczne wszystkie typy i składowe typu oznaczone internal słowem kluczowym.
TypeId

Po zaimplementowaniu w klasie pochodnej pobiera unikatowy identyfikator dla tego Attributeelementu .

(Odziedziczone po Attribute)

Metody

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

(Odziedziczone po Attribute)
GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.

(Odziedziczone po Attribute)
GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
IsDefaultAttribute()

W przypadku zastąpienia w klasie pochodnej wskazuje, czy wartość tego wystąpienia jest wartością domyślną klasy pochodnej.

(Odziedziczone po Attribute)
Match(Object)

Po przesłonięciu w klasie pochodnej zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.

(Odziedziczone po Attribute)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Jawne implementacje interfejsu

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

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.

(Odziedziczone po Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Pobiera informacje o typie dla obiektu, który może służyć do pobierania informacji o typie dla interfejsu.

(Odziedziczone po Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).

(Odziedziczone po Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Umożliwia dostęp do właściwości i metod udostępnianych przez obiekt.

(Odziedziczone po Attribute)

Dotyczy