InternalsVisibleToAttribute Clase

Definición

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

Herencia

Object

Attribute

InternalsVisibleToAttribute

Atributos

AttributeUsageAttribute

Ejemplos

Ensamblados firmados

En el ejemplo siguiente se usa el InternalsVisibleToAttribute atributo para hacer que un internal método denominado AppendDirectorySeparator en un ensamblado firmado sea visible para otro ensamblado firmado. Define una FileUtilities clase que incluye un método interno AppendDirectorySeparator . El InternalsVisibleToAttribute atributo se aplica al ensamblado que contiene la FileUtilities clase . El atributo permite que un ensamblado denominado Friend1 acceda a este miembro interno.

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

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

Ensamblados sin firmar

En el ejemplo siguiente se usa el InternalsVisibleToAttribute atributo para hacer que un internal miembro de un ensamblado sin firmar sea visible para otro ensamblado sin firmar. El atributo garantiza que el internalStringLib.IsFirstLetterUpperCase método de un ensamblado denominado UtilityLib sea visible para el código de un ensamblado denominado Friend2. A continuación se muestra el código fuente de 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. Tenga en cuenta que si está compilando en C# desde la línea de comandos, debe usar el modificador del compilador /out para asegurarse de que el nombre del ensamblado de confianza está disponible cuando el compilador se enlaza a referencias externas.

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

Comentarios

El InternalsVisibleToAttribute atributo especifica que los tipos que normalmente son visibles solo dentro del ensamblado actual son visibles para un ensamblado especificado.

Normalmente, los tipos y miembros con internal ámbito en C# o Friend ámbito de Visual Basic solo están visibles en el ensamblado en el que se definen. Los tipos y miembros con ámbito protected internal (ámbito Protected Friend en Visual Basic) solo son visibles dentro de su propio ensamblado o en tipos que derivan de su clase contenedora. Los tipos y miembros con private protected ámbito (Private Protected ámbito en Visual Basic) están visibles en la clase contenedora o en los tipos que derivan de su clase contenedora dentro del ensamblado actual.

El InternalsVisibleToAttribute atributo hace que estos tipos y miembros también sean visibles para los tipos de un ensamblado especificado, que se conoce como ensamblado amigo. Esto solo se aplica a los miembros internal (Friend en Visual Basic), protected internal (Protected Friend en Visual Basic), y private protected (Private Protected en Visual Basic), pero no a private.

El atributo se aplica en el nivel de ensamblado. 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. Puede usar el atributo para especificar un único ensamblado amiga que pueda tener acceso a los tipos y miembros internos del ensamblado actual. Puede definir varios ensamblados de confianza de dos formas. Pueden aparecer como atributos individuales de nivel de ensamblado, como se muestra en el ejemplo siguiente.

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

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

También pueden aparecer con etiquetas independientes InternalsVisibleToAttribute , pero una sola assembly palabra clave, como se muestra en el ejemplo siguiente.

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

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

El ensamblado de confianza lo identifica el constructor InternalsVisibleToAttribute. Tanto el ensamblado actual como el ensamblado de confianza no deben estar firmados, o bien ambos ensamblados deben estar firmados con un nombre seguro.

Si ambos ensamblados no están firmados, el assemblyName argumento consta del nombre del ensamblado amigo, especificado sin una ruta de directorio o una extensión de archivo.

Si ambos ensamblados están firmados con un nombre seguro, el argumento para el InternalsVisibleToAttribute constructor debe constar del nombre del ensamblado sin su ruta de acceso de directorio o extensión de nombre de archivo, junto con la clave pública completa (y no su token de clave pública). Para obtener la clave pública completa de un ensamblado con nombre seguro, consulte la sección Obtención de la clave pública completa más adelante en este artículo. Para obtener más información sobre el uso de InternalsVisibleToAttribute con ensamblados con nombre seguro, consulte el constructor InternalsVisibleToAttribute.

No incluya valores para el CultureInfocampo , Versiono ProcessorArchitecture en el argumento; los compiladores de Visual Basic, C#y C++ tratan esto como un error del compilador. Si usa un compilador que no lo trata como un error (como el ensamblador de IL (ILAsm.exe)) y los ensamblados tienen un nombre firmado, se produce una MethodAccessException excepción la primera vez que el ensamblado amigo especificado accede al ensamblado que contiene el InternalsVisibleToAttribute atributo.

Para obtener más información sobre cómo usar este atributo, vea Ensamblados de confianza y ensamblados de confianza de C++.

Obtención de la clave pública completa

Puede usar la herramienta de nombre seguro (Sn.exe) para recuperar la clave pública completa de un archivo de clave con nombre seguro (.snk). Para ello, realice los pasos siguientes:

1. Extraiga la clave pública del archivo de clave con nombre seguro en un archivo independiente:

   Sn -p <snk_file> <outfile>

2. Muestra la clave pública completa en la consola:

   Sn -tp <outfile>

3. Copie y pegue el valor de clave pública completa en el código fuente.

Compila el ensamblado amigo con C#

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

Compila la ensambladura amiga con C++

En C++, para que los miembros internos habilitados por el atributo InternalsVisibleToAttribute sean accesibles para un ensamblado amigo, debe usar el atributo as_friend en la directiva C++. Para obtener más información, vea Ensamblados de confianza (C++).