InternalsVisibleToAttribute(String) Constructor
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Inicializa una nueva instancia de la clase InternalsVisibleToAttribute con el nombre del ensamblado de confianza especificado.
public:
InternalsVisibleToAttribute(System::String ^ assemblyName);public InternalsVisibleToAttribute (string assemblyName);new System.Runtime.CompilerServices.InternalsVisibleToAttribute : string -> System.Runtime.CompilerServices.InternalsVisibleToAttributePublic Sub New (assemblyName As String)Parámetros
- assemblyName
- String
El nombre de un ensamblado de confianza.
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, puede llamar correctamente al FileUtilities.AppendDirectorySeparator método , aunque el método sea interno para el Assembly1 ensamblado. Tenga en cuenta que 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 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\
En el ejemplo siguiente se usa el InternalsVisibleToAttribute atributo para 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
Ensamblados sin firmar
En el ejemplo siguiente se proporciona el código fuente para el Friend2 ensamblado. Tenga en cuenta que 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.
#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
El InternalsVisibleToAttribute constructor define un ensamblado friend, que es un ensamblado que tiene acceso a los tipos protegidos internos y privados y a los miembros del ensamblado actual.
Tanto el ensamblado actual como el ensamblado friend deben estar sin firmar, o ambos deben estar firmados con un nombre seguro. (Para obtener más información sobre los ensamblados con nombre seguro, consulte Create y use ensamblados con nombre seguro). Si ambos no están firmados, el assemblyName argumento consta del nombre del ensamblado friend, especificado sin una ruta de acceso de directorio o una extensión de archivo. Si ambos están firmados, assemblyName consta del nombre del ensamblado friend sin su ruta de acceso de directorio o extensión de nombre de archivo, junto con su clave pública completa (pero no su token de clave pública). Los demás componentes de un nombre seguro, como los que proporcionan información de la arquitectura de la referencia cultural, la versión o el procesador, no se pueden especificar en el assemblyName argumento .
Importante
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 no ha generado aún 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 la opción del compilador -out o -o correspondiente no se debe usar al compilar ensamblados de confianza con el compilador de F#.
Puede usar Sn.exe (Herramienta de nombre seguro) para recuperar la clave pública completa de un archivo de clave segura (.snk). Para ello, realice los pasos siguientes:
Extraiga la clave pública del archivo de clave con nombre seguro en un archivo independiente:
Sn -psnk_fileoutfile
Muestra la clave pública completa en la consola:
Sn -tpoutfile
Copie y pegue el valor de clave pública completa en el código fuente.
Para obtener más información sobre cómo usar el InternalsVisibleToAttribute atributo, consulte los artículos siguientes:
Se aplica a
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de