InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute Class

Definición

Especifica que los tipos que normalmente solo son visibles en el ensamblado actual también se pueden ver en un ensamblado especificado.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
Herencia
InternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttribute
Atributos

Ejemplos

Ensamblados firmadosSigned assemblies

En el ejemplo siguiente se usa el InternalsVisibleToAttribute atributo para realizar una internal método denominado AppendDirectorySeparator en un ensamblado firmado visible a otro ensamblado con signo.The following example uses the InternalsVisibleToAttribute attribute to make an internal method named AppendDirectorySeparator in a signed assembly visible to another signed assembly. Define un FileUtilities clase que incluye una instancia interna AppendDirectorySeparator método.It defines a FileUtilities class that includes an internal AppendDirectorySeparator method. El InternalsVisibleToAttribute atributo se aplica al ensamblado que contiene el FileUtilities clase.The InternalsVisibleToAttribute attribute is applied to the assembly that contains the FileUtilities class. El atributo permite que un ensamblado denominado Friend1 para tener acceso a este miembro interno.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

Si en el ejemplo siguiente se compila en un ensamblado con nombre seguro denominado Friend1, el Example.Main método Friend1 correctamente puede llamar a la FileUtilities.AppendDirectorySeparator método, aunque el método es interno a la Assembly1 ensamblado.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. Tenga en cuenta que si está compilando en C# desde la línea de comandos, se debe usar el /out modificador del compilador para asegurarse de que el nombre del ensamblado de confianza está disponible cuando el compilador enlaza a referencias externas.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\

Ensamblados no firmadosUnsigned assemblies

En el ejemplo siguiente se usa el InternalsVisibleToAttribute atributo para realizar una internal unsigned de miembro de un ensamblado no firmado visible a otro ensamblado.The following example uses the InternalsVisibleToAttribute attribute to make an internal member of an unsigned assembly visible to another unsigned assembly. El atributo que garantiza la internal StringLib.IsFirstLetterUpperCase método en un ensamblado denominado UtilityLib es visible para el código en un ensamblado denominado 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. Este es el código fuente de 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

En el ejemplo siguiente se proporciona el código fuente para el Friend2 ensamblado.The following example provides the source code for the Friend2 assembly. Tenga en cuenta que si está compilando en C# desde la línea de comandos, se debe usar el /out modificador del compilador para asegurarse de que el nombre del ensamblado de confianza está disponible cuando el compilador enlaza a referencias externas.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

Comentarios

Normalmente, los tipos y miembros con internal o private protected ámbito (en C#) y Friend y Private Protected ámbito (en Visual Basic) solo son visibles en el ensamblado en el que se definen.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. El InternalsVisibleToAttribute atributo hace que sean también visibles a los tipos en un ensamblado especificado, que se conoce como un ensamblado de confianza.The InternalsVisibleToAttribute attribute makes them also visible to the types in a specified assembly, which is known as a friend assembly. Esto se aplica solo a internal (Friend en VB) o private protected(Private Protected en VB) métodos únicamente, pero no private aquellos.This only applies to internal (Friend in VB) or private protected(Private Protected in VB) methods only, but not private ones.

El atributo se aplica en el nivel de ensamblado.The attribute is applied at the assembly level. Esto significa que se puede incluir al principio de un archivo de código fuente, o se puede incluir en el archivo AssemblyInfo en un proyecto de 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. Puede usar el atributo para especificar un ensamblado de confianza único que puede tener acceso a los tipos y miembros internos del ensamblado actual.You can use the attribute to specify a single friend assembly that can access the internal types and members of the current assembly. Puede definir varios ensamblados de confianza de dos maneras.You can define multiple friend assemblies in two ways. Pueden aparecer como atributos individuales de nivel de ensamblado, como se muestra en el ejemplo siguiente.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")>

También pueden aparecer con independiente InternalsVisibleToAttribute etiquetas, pero una sola assembly palabra clave, como en el ejemplo siguiente se muestra.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")>

El ensamblado de confianza se identifica mediante el InternalsVisibleToAttribute constructor.The friend assembly is identified by the InternalsVisibleToAttribute constructor. El ensamblado actual y el ensamblado de confianza deben ser sin signo o ambos ensamblados deben firmarse con un nombre seguro.Both the current assembly and the friend assembly must be unsigned, or both assemblies must be signed with a strong name.

Si ambos ensamblados son sin signo, el assemblyName argumento consta del nombre del ensamblado de confianza, especificado sin una extensión de nombre de archivo o ruta de acceso del directorio.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.

Si ambos ensamblados se firman con una fuerte nombre, el argumento para el InternalsVisibleToAttribute constructor debe consistir en el nombre del ensamblado sin su directorio ruta de acceso o archivo de extensión de nombre, junto con la clave pública completa (y no su token de clave pública).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). Para obtener la clave pública completa de un ensamblado con nombre seguro, consulte el obtener la clave pública completa sección más adelante en este artículo.To get the full public key of a strong-named assembly, see the Getting the full public key section later in this article. Para obtener más información sobre el uso de InternalsVisibleToAttribute con ensamblados de nombre seguro, vea el InternalsVisibleToAttribute constructor.For more information about using InternalsVisibleToAttribute with strong-named assemblies, see the InternalsVisibleToAttribute constructor.

No incluya valores para el CultureInfo, Version, o ProcessorArchitecture campo en el argumento; los compiladores de Visual Basic, C# y C++ tratan como un error del compilador.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. Si usa un compilador que no lo trata como un error (como el ensamblador de IL (ILAsm.exe)) y los ensamblados tienen nombres seguros, un MethodAccessException excepción se produce la primera vez que el ensamblado de confianza especificado tiene acceso a la ensamblado que contiene el InternalsVisibleToAttribute atributo.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.

Para obtener más información sobre cómo usar este atributo, vea los temas siguientes:For more information about how to use this attribute, see the following topics:

Obtener la clave pública completaGetting the full public key

Puede usar el herramienta nombre seguro (Sn.exe) para recuperar la clave pública completa de un archivo de clave con nombre seguro (.snk).You can use the Strong Name Tool (Sn.exe) to retrieve the full public key from a strong-named key (.snk) file. Para ello, realice los pasos siguientes:To do this, you perform the following steps:

  1. Extraiga la clave pública desde el archivo de clave con nombre seguro a un archivo independiente:Extract the public key from the strong-named key file to a separate file:

    Sn -p snk_file outfileSn -p snk_file outfile

  2. Mostrar la clave pública completa en la consola:Display the full public key to the console:

    *Sn - tp***outfileSn -tp outfile

  3. Copie y pegue el valor de clave público completa en el código fuente.Copy and paste the full public key value into your source code.

Compilar el ensamblado de confianza con C#Compiling the friend assembly with C#

Si usa el compilador de C# para compilar el ensamblado de confianza, debe especificar explícitamente el nombre del archivo de salida (.exe o .dll) mediante la /out opción del compilador.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. Esto es necesario porque el compilador no ha generado aún el nombre del ensamblado que está creando en el momento en que se enlaza a referencias externas.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. El /out es opcional para el compilador de Visual Basic y la correspondiente opción del compilador -out o -o opción del compilador no debe usarse cuando se compila friend los ensamblados con el F# compilador.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.

Compilar el ensamblado de confianza con C++Compiling the friend assembly with C++

En C++, con el fin de realizar los miembros internos habilitados por la InternalsVisibleToAttribute atributo puede tener acceso a un ensamblado de confianza, debe usar el as_friend atributo en la directiva de 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. Para obtener más información, consulte ensamblados Friend (C++).For more information, see Friend Assemblies (C++).

Constructores

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

Inicializa una nueva instancia de la clase InternalsVisibleToAttribute con el nombre del ensamblado de confianza especificado.Initializes a new instance of the InternalsVisibleToAttribute class with the name of the specified friend assembly.

Propiedades

AllInternalsVisible AllInternalsVisible AllInternalsVisible AllInternalsVisible

Esta propiedad no está implementada.This property is not implemented.

AssemblyName AssemblyName AssemblyName AssemblyName

Obtiene el nombre del ensamblado de confianza para el que todos los tipos y miembros de tipo marcados con la palabra clave internal se van ha hacer visibles.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

Cuando se implementa en una clase derivada, obtiene un identificador único para este Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Métodos

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

Devuelve un valor que indica si esta instancia es igual que un objeto especificado.Returns a value that indicates whether this instance is equal to a specified object.

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

Devuelve el código hash de esta instancia.Returns the hash code for this instance.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Si se reemplaza en una clase derivada, indica si el valor de esta instancia es el valor predeterminado de la clase derivada.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)

Cuando se invalida en una clase derivada, devuelve un valor que indica si esta instancia es igual a un objeto especificado.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()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

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

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Implementaciones de interfaz explícitas

_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)

Asigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío.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)

Obtiene la información de tipos de un objeto, que puede utilizarse para obtener la información de tipos de una interfaz.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)

Recupera el número de interfaces de información de tipo que proporciona un objeto (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)

Proporciona acceso a las propiedades y los métodos expuestos por un objeto.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Se aplica a