InternalsVisibleToAttribute Klasa

Definicja

Określa, że typy, które są zwykle widoczne tylko w bieżącym zestawie, są widoczne dla określonego zestawu.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
Dziedziczenie
InternalsVisibleToAttribute
Atrybuty

Przykłady

Podpisane zestawySigned assemblies

Poniższy przykład używa atrybutu InternalsVisibleToAttribute, aby utworzyć internal metodę o nazwie AppendDirectorySeparator w podpisanym zestawie widocznym dla innego podpisanego zestawu.The following example uses the InternalsVisibleToAttribute attribute to make an internal method named AppendDirectorySeparator in a signed assembly visible to another signed assembly. Definiuje klasę FileUtilities, która zawiera wewnętrzną metodę AppendDirectorySeparator.It defines a FileUtilities class that includes an internal AppendDirectorySeparator method. Atrybut InternalsVisibleToAttribute jest stosowany do zestawu, który zawiera klasę FileUtilities.The InternalsVisibleToAttribute attribute is applied to the assembly that contains the FileUtilities class. Ten atrybut zezwala na zestaw o nazwie Friend1, aby uzyskać dostęp do tego wewnętrznego elementu członkowskiego.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

Jeśli Poniższy przykład jest kompilowany do zestawu o silnej nazwie Friend1, Metoda Example.Main w Friend1 może pomyślnie wywołać metodę FileUtilities.AppendDirectorySeparator, chociaż Metoda jest wewnętrzna dla zestawu Assembly1.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. Należy pamiętać, że w przypadku kompilowania w C# wierszu 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.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\

Niepodpisane zestawyUnsigned assemblies

Poniższy przykład używa atrybutu InternalsVisibleToAttribute, aby uczynić element członkowski internal niepodpisanego zestawu widoczny dla innego niepodpisanego zestawu.The following example uses the InternalsVisibleToAttribute attribute to make an internal member of an unsigned assembly visible to another unsigned assembly. Ten atrybut zapewnia, że metoda internal StringLib.IsFirstLetterUpperCase w zestawie o nazwie UtilityLib jest widoczna dla kodu w zestawie o nazwie 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. Poniżej znajduje się kod źródłowy dla 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

Poniższy przykład zawiera kod źródłowy dla zestawu Friend2.The following example provides the source code for the Friend2 assembly. Należy pamiętać, że w przypadku kompilowania w C# wierszu 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.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

Uwagi

Zwykle typy i elementy członkowskie z zakresem internal lub private protected ( C#in) i Friend i zakresem Private Protected (w Visual Basic) są widoczne tylko w zestawie, w którym są zdefiniowane.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. Atrybut InternalsVisibleToAttribute sprawia, że są one również widoczne dla typów w określonym zestawie, który jest znany jako zestaw zaprzyjaźniony.The InternalsVisibleToAttribute attribute makes them also visible to the types in a specified assembly, which is known as a friend assembly. Dotyczy to tylko internal (Friend w języku VB) lub private protected(Private Protected w języku VB), ale nie private.This only applies to internal (Friend in VB) or private protected(Private Protected in VB) methods only, but not private ones.

Ten atrybut jest stosowany na poziomie zestawu.The attribute is applied at the assembly level. Oznacza to, że można ją uwzględnić na początku pliku kodu źródłowego lub umieścić w pliku AssemblyInfo w projekcie programu Visual Studio.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. Możesz użyć atrybutu, aby określić pojedynczy zestaw zaprzyjaźniony, który może uzyskać dostęp do typów wewnętrznych i elementów członkowskich bieżącego zestawu.You can use the attribute to specify a single friend assembly that can access the internal types and members of the current assembly. Można zdefiniować wiele zestawów zaprzyjaźnionych na dwa sposoby.You can define multiple friend assemblies in two ways. Mogą one być wyświetlane jako pojedyncze atrybuty na poziomie zestawu, jak pokazano w poniższym przykładzie.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")>

Mogą być również wyświetlane z oddzielnymi tagami InternalsVisibleToAttribute, ale assembly słowa kluczowego pojedynczego, jak pokazano w poniższym przykładzie.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")>

Zestaw zaprzyjaźniony jest identyfikowany przez konstruktora InternalsVisibleToAttribute.The friend assembly is identified by the InternalsVisibleToAttribute constructor. Zarówno bieżący zestaw, jak i zestaw zaprzyjaźniony muszą być niepodpisane lub oba muszą być podpisane za pomocą silnej nazwy.Both the current assembly and the friend assembly must be unsigned, or both assemblies must be signed with a strong name.

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

Jeśli oba zestawy są podpisane przy użyciu silnej nazwy, argument konstruktora InternalsVisibleToAttribute 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).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). Aby uzyskać pełny klucz publiczny zestawu o silnej nazwie, zobacz sekcję pobieranie pełnego klucza publicznego w dalszej części tego artykułu.To get the full public key of a strong-named assembly, see the Getting the full public key section later in this article. Aby uzyskać więcej informacji na temat używania InternalsVisibleToAttribute z zestawami o silnych nazwach, zobacz konstruktora InternalsVisibleToAttribute.For more information about using InternalsVisibleToAttribute with strong-named assemblies, see the InternalsVisibleToAttribute constructor.

W argumencie nie należy uwzględniać wartości pola CultureInfo, Versionlub ProcessorArchitecture Visual Basic, C#i C++ kompilatory traktują go jako błąd kompilatora.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. Jeśli używasz kompilatora, który nie traktuje go jako błąd (na przykład asemblera Il (Ilasm. exe)), a zestawy są o silnej nazwie, zostanie zgłoszony wyjątek MethodAccessException, podczas gdy określony znajomy zestaw uzyskuje dostęp do zestawu, który zawiera atrybut InternalsVisibleToAttribute.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.

Więcej informacji o sposobach korzystania z tego atrybutu znajduje się w następujących tematach:For more information about how to use this attribute, see the following topics:

Pobieranie pełnego klucza publicznegoGetting the full public key

Za pomocą Narzędzia silnej nazwy (SN. exe) można pobrać pełny klucz publiczny z pliku klucza o silnej nazwie (SNK).You can use the Strong Name Tool (Sn.exe) to retrieve the full public key from a strong-named key (.snk) file. W tym celu wykonaj następujące czynności:To do this, you perform the following steps:

  1. Wyodrębnij klucz publiczny z pliku klucza o silnej nazwie do oddzielnego pliku:Extract the public key from the strong-named key file to a separate file:

    SN-p snk_file plikuSn -p snk_file outfile

  2. Wyświetl pełny klucz publiczny w konsoli programu:Display the full public key to the console:

    Deplika SN-TPSn -tp outfile

  3. Skopiuj i wklej pełną wartość klucza publicznego do kodu źródłowego.Copy and paste the full public key value into your source code.

Kompilowanie zestawu zaprzyjaźnionego za pomocąC#Compiling the friend assembly with C#

Jeśli używasz C# kompilatora do kompilowania zestawu zaprzyjaźnionego, musisz jawnie określić nazwę pliku wyjściowego (. exe lub. dll) przy użyciu opcji kompilatora /out .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. Jest to wymagane, ponieważ kompilator nie wygenerował jeszcze nazwy dla zestawu, który jest tworzony w momencie powiązania z odwołaniami zewnętrznymi.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. Opcja kompilatora /out jest opcjonalna dla kompilatora Visual Basic i nie należy używać odpowiedniej opcji kompilatora lub -o w przypadku kompilowania zespołów zaprzyjaźnionych z F# kompilatorem.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.

Kompilowanie zestawu zaprzyjaźnionego za pomocąC++Compiling the friend assembly with C++

W C++programie, aby wewnętrzne elementy członkowskie z włączonym atrybutem InternalsVisibleToAttribute miały dostęp do zestawu zaprzyjaźnionego, należy użyć atrybutu as_friend w C++ dyrektywie.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. Aby uzyskać więcej informacji, zobacz zaprzyjaźnioneC++zestawy ().For more information, see Friend Assemblies (C++).

Konstruktory

InternalsVisibleToAttribute(String)

Inicjuje nowe wystąpienie klasy InternalsVisibleToAttribute z nazwą podanego zestawu zaprzyjaźnionego.Initializes a new instance of the InternalsVisibleToAttribute class with the name of the specified friend assembly.

Właściwości

AllInternalsVisible

Ta właściwość nie jest zaimplementowana.This property is not implemented.

AssemblyName

Pobiera nazwę zaprzyjaźnionego zestawu, do którego wszystkie typy i elementy członkowskie typu oznaczone za pomocą słowa kluczowego internal mają być widoczne.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

Po zaimplementowaniu w klasie pochodnej pobiera unikatowy identyfikator dla tego Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Odziedziczone po Attribute)

Metody

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.Returns a value that indicates whether this instance is equal to a specified object.

(Odziedziczone po Attribute)
GetHashCode()

Zwraca kod skrótu dla tego wystąpienia.Returns the hash code for this instance.

(Odziedziczone po Attribute)
GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
IsDefaultAttribute()

Gdy jest zastępowany w klasie pochodnej, wskazuje, czy wartość tego wystąpienia jest wartością domyślną klasy pochodnej.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Odziedziczone po Attribute)
Match(Object)

Gdy jest zastępowany w klasie pochodnej, zwraca wartość wskazującą, czy to wystąpienie jest zgodne z określonym obiektem.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Odziedziczone po Attribute)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

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

Zestaw nazw jest mapowany na odpowiedni zestaw identyfikatorów wysyłania.Maps a set of names to a corresponding set of dispatch identifiers.

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

Pobiera informacje o typie dla obiektu, którego można użyć do uzyskania informacji o typie dla interfejsu.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Odziedziczone po Attribute)
_Attribute.GetTypeInfoCount(UInt32)

Pobiera informację o liczbie typów interfejsów, jakie zawiera obiekt (0 lub 1).Retrieves the number of type information interfaces that an object provides (either 0 or 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.Provides access to properties and methods exposed by an object.

(Odziedziczone po Attribute)

Dotyczy