InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute Class

Определение

Задает, что типы, видимые обычно только в пределах текущей сборки, являются видимыми для заданной сборки.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
Наследование
InternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttribute
Атрибуты

Примеры

Подписанные сборкиSigned assemblies

В следующем примере InternalsVisibleToAttribute атрибут используется для internal того, чтобы метод, AppendDirectorySeparator названный в подписанной сборке, был виден другой подписанной сборке.The following example uses the InternalsVisibleToAttribute attribute to make an internal method named AppendDirectorySeparator in a signed assembly visible to another signed assembly. Он определяет FileUtilities класс, включающий внутренний AppendDirectorySeparator метод.It defines a FileUtilities class that includes an internal AppendDirectorySeparator method. Атрибут применяется к сборке, FileUtilities содержащей класс. InternalsVisibleToAttributeThe InternalsVisibleToAttribute attribute is applied to the assembly that contains the FileUtilities class. Атрибут позволяет сборке с именем Friend1 получить доступ к этому внутреннему элементу.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

Если Friend1следующий пример компилируется в сборку со строгим именем Example.Main , метод FileUtilities.AppendDirectorySeparator в Friend1 может успешно вызвать метод, хотя метод является внутренним для 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. Обратите внимание, что при компиляции в C# из командной строки необходимо использовать параметр компилятора /out , чтобы убедиться, что имя дружественной сборки доступно, когда компилятор привязывается к внешним ссылкам.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\

Неподписанные сборкиUnsigned assemblies

В следующем примере InternalsVisibleToAttribute атрибут используется для internal того, чтобы сделать член неподписанной сборки видимым для другой неподписанной сборки.The following example uses the InternalsVisibleToAttribute attribute to make an internal member of an unsigned assembly visible to another unsigned assembly. internal Атрибут гарантирует, что StringLib.IsFirstLetterUpperCase метод в сборке с именем UtilityLib будет виден коду в сборке с именем 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. Ниже приведен исходный код для Утилитилиб. 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

В следующем примере показан исходный код для Friend2 сборки.The following example provides the source code for the Friend2 assembly. Обратите внимание, что при компиляции в C# из командной строки необходимо использовать параметр компилятора /out , чтобы убедиться, что имя дружественной сборки доступно, когда компилятор привязывается к внешним ссылкам.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

Комментарии

Как правило, типы и члены internal с private protected областью действия C# Private Protected (in Friend ) и областью действия (в Visual Basic) видимы только в той сборке, в которой они определены.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. InternalsVisibleToAttribute Атрибут делает их видимыми для типов в указанной сборке, которая называется дружественной сборкой.The InternalsVisibleToAttribute attribute makes them also visible to the types in a specified assembly, which is known as a friend assembly. Это применимо только internal кFriend (в VB) private protectedилиPrivate Protected только к методам (только в VB private ), но не к.This only applies to internal (Friend in VB) or private protected(Private Protected in VB) methods only, but not private ones.

Атрибут применяется на уровне сборки.The attribute is applied at the assembly level. Это означает, что он может быть добавлен в начало файла исходного кода, или его можно добавить в файл AssemblyInfo в проекте 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. Атрибут можно использовать для указания одной дружественной сборки, которая может обращаться к внутренним типам и членам текущей сборки.You can use the attribute to specify a single friend assembly that can access the internal types and members of the current assembly. Можно определить несколько дружественных сборок двумя способами.You can define multiple friend assemblies in two ways. Они могут отображаться как отдельные атрибуты уровня сборки, как показано в следующем примере.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")>

Они также могут отображаться с отдельными InternalsVisibleToAttribute тегами, но с assembly одним ключевым словом, как показано в следующем примере.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")>

Дружественная сборка определяется InternalsVisibleToAttribute конструктором.The friend assembly is identified by the InternalsVisibleToAttribute constructor. Как текущая сборка, так и дружественная сборка должны быть неподписанными, либо обе сборки должны быть подписаны строгим именем.Both the current assembly and the friend assembly must be unsigned, or both assemblies must be signed with a strong name.

Если обе сборки не подписаны, assemblyName аргумент состоит из имени дружественной сборки, указанной без пути к каталогу или расширения имени файла.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.

Если обе сборки подписаны строгим именем, аргумент InternalsVisibleToAttribute конструктора должен состоять из имени сборки без пути к каталогу или расширения имени файла вместе с полным открытым ключом (а не маркером открытого ключа).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). Чтобы получить полный открытый ключ сборки со строгим именем, ознакомьтесь с разделом Получение полного открытого ключа далее в этой статье.To get the full public key of a strong-named assembly, see the Getting the full public key section later in this article. Дополнительные сведения об использовании InternalsVisibleToAttribute со сборками со строгими именами см. в InternalsVisibleToAttribute разделе Конструктор.For more information about using InternalsVisibleToAttribute with strong-named assemblies, see the InternalsVisibleToAttribute constructor.

CultureInfoНе включайте значения для поля, Versionили ProcessorArchitecture в аргументе; компиляторы Visual Basic, C#, и C++ обрабатывают это как ошибку компилятора.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. Если вы используете компилятор, который не обрабатывает его как ошибку (например, ассемблер IL (Ilasm. exe)) и сборки имеют строгое имя, MethodAccessException исключение создается при первом обращении указанной дружественной сборки к сборке, содержащей 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.

Дополнительные сведения об использовании этого атрибута см. в следующих разделах:For more information about how to use this attribute, see the following topics:

Получение полного открытого ключаGetting the full public key

Средство строгих имен (Sn. exe) можно использовать для получения полного открытого ключа из файла ключа с строгой подписью (. snk).You can use the Strong Name Tool (Sn.exe) to retrieve the full public key from a strong-named key (.snk) file. Для этого выполните следующие действия.To do this, you perform the following steps:

  1. Извлеките открытый ключ из файла ключа со строгим именем в отдельный файл:Extract the public key from the strong-named key file to a separate file:

    Sn-p snk_file файлSn -p snk_file outfile

  2. Отобразите полный открытый ключ для консоли:Display the full public key to the console:

    SN-TP файлSn -tp outfile

  3. Скопируйте и вставьте значение полного открытого ключа в исходный код.Copy and paste the full public key value into your source code.

Компиляция дружественной сборки с помощьюC#Compiling the friend assembly with C#

Если для компиляции дружественной сборки используется C# компилятор, необходимо явно указать имя выходного файла (exe или DLL) с помощью параметра компилятора /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. Это необходимо потому, что компилятор еще не создал имя сборки, формируемой во время привязки к внешним ссылкам.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. Параметр компилятора /out является необязательным для Visual Basic компилятора, и не следует использовать соответствующий параметр компилятора или -o при компиляции дружественных сборок с помощью F# компилятора.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.

Компиляция дружественной сборки с помощьюC++Compiling the friend assembly with C++

В C++для того, чтобы внутренние члены, включенные InternalsVisibleToAttribute атрибутом, были доступны для дружественной сборки, необходимо использовать as_friend атрибут в C++ директиве.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. Дополнительные сведения см. в разделе дружественныеC++сборки ().For more information, see Friend Assemblies (C++).

Конструкторы

InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String)

Инициализирует новый экземпляр класса InternalsVisibleToAttribute с именем заданной дружественной сборки.Initializes a new instance of the InternalsVisibleToAttribute class with the name of the specified friend assembly.

Свойства

AllInternalsVisible AllInternalsVisible AllInternalsVisible AllInternalsVisible

Это свойство не реализовано.This property is not implemented.

AssemblyName AssemblyName AssemblyName AssemblyName

Получает имя дружественной сборки, для которой будут сделаны доступными все типы и члены типов, помеченные ключевым словом internal.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 TypeId TypeId TypeId

При реализации в производном классе возвращает уникальный идентификатор для этого Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Методы

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Возвращает значение, показывающее, равен ли экземпляр указанному объекту.Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from Attribute)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Возвращает хэш-код данного экземпляра.Returns the hash code for this instance.

(Inherited from Attribute)
GetType() GetType() GetType() GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Inherited from Object)
IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute()

При переопределении в производном классе указывает, является ли значение этого экземпляра значением по умолчанию для производного класса.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Inherited from Attribute)
Match(Object) Match(Object) Match(Object) Match(Object)

При переопределении в производном классе возвращает значение, указывающее, является ли этот экземпляр равным заданному объекту.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Inherited from Attribute)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Inherited from Object)

Явные реализации интерфейса

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

Сопоставляет набор имен соответствующему набору идентификаторов диспетчеризации.Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Возвращает сведения о типе объекта, которые можно использовать для получения сведений о типе интерфейса.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from Attribute)
_Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32)

Возвращает количество предоставляемых объектом интерфейсов для доступа к сведениям о типе (0 или 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Предоставляет доступ к открытым свойствам и методам объекта.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Применяется к