Ensamblados de confianza (Guía de programación de C#)

Actualización: noviembre 2007

Se puede tener acceso a un tipo interno o miembro interno de un ensamblado desde otro ensamblado.

Comentarios

La característica de ensamblados de confianza permite tener acceso a los miembros internos; los tipos y miembros privados permanecerán inaccesibles.

Para dar a un ensamblado (ensamblado B) acceso a los tipos y miembros internos de otro ensamblado (ensamblado A), utilice el atributo InternalsVisibleToAttribute en el ensamblado A.

Nota:

Cuando compile un ensamblado (ensamblado B) que tendrá acceso a los tipos o miembros internos de otro ensamblado (ensamblado A), debe especificar explícitamente el nombre del archivo de resultados (.exe o .dll) con la opción del compilador /out (vea /out (Establecer el nombre de archivo de los resultados) (Opciones del compilador de C#) para obtener más información). Esto es necesario porque el compilador no ha generado aún el nombre del ensamblado que está creando en el momento de enlazar a las referencias externas.

La clase StrongNameIdentityPermission también proporciona la capacidad de compartir tipos, con las diferencias siguientes:

• StrongNameIdentityPermission se aplica a un tipo individual, mientras que un ensamblado de confianza se aplica a todo el ensamblado.

• Si hay cientos de tipos en el ensamblado A que desea compartir con el ensamblado B, debe decorar cada uno de estos tipos con StrongNameIdentityPermission, mientras que al utilizar un ensamblado de confianza, sólo deberá declarar la relación de confianza una vez.

• Con StrongNameIdentityPermission, los tipos que desea compartir se deben declarar como públicos. Con un ensamblado de confianza, los tipos compartidos se declaran como privados.

• Para obtener información sobre cómo generar un módulo .netmodule que pueda tener acceso a tipos no públicos en un ensamblado, vea /moduleassemblyname (Especificar un ensamblado de confianza para el módulo) (Opciones del compilador de C#).

Ejemplo

En este ejemplo, el ensamblado hace que los tipos y miembros internos sean visibles para el ensamblado denominado cs_friend_assemblies_2.

// cs_friend_assemblies.cs
// compile with: /target:library
using System.Runtime.CompilerServices;
using System;

[assembly:InternalsVisibleTo("cs_friend_assemblies_2")]

// internal by default
class Class1 
{
    public void Test() 
    {
        Console.WriteLine("Class1.Test");
    }
}

// public type with internal member
public class Class2 
{
    internal void Test() 
    {
        Console.WriteLine("Class2.Test");
    }
}

En este ejemplo, el ensamblado utiliza los tipos y miembros internos del ensamblado cs_friend_assemblies.dll.

Observe que debe especificar explícitamente el nombre del archivo de resultados (/out:cs_friend_assemblies_2.exe).

Si este ensamblado da a otro ensamblado (ensamblado C) acceso a sus tipos y miembros internos, el ensamblado C no pasa automáticamente a ser de confianza para el ensamblado cs_friend_assemblies.dll.

// cs_friend_assemblies_2.cs
// compile with: /reference:cs_friend_assemblies.dll /out:cs_friend_assemblies_2.exe
public class M 
{
    static void Main() 
    {
        // access an internal type
        Class1 a = new Class1();
        a.Test();

        Class2 b = new Class2();
        // access an internal member of a public type
        b.Test();
    }
}

Class1.Test
Class2.Test

En este ejemplo se muestra cómo hacer que los tipos y miembros internos estén disponibles para los ensamblados que tienen nombres seguros.

Para generar el archivo de claves y mostrar la clave pública, utilice el siguiente scripting de sn.exe (para obtener más información, vea Herramienta de nombre seguro (Sn.exe)):

• sn -k friend_assemblies.snk // Genera la clave de nombre seguro

• sn -p friend_assemblies.snk key.publickey // Extrae la clave pública de key.snk a key.publickey

• sn -tp key.publickey // Muestra la clave pública almacenada en file'key.publickey

Pase el archivo de claves al compilador con /keyfile.

// cs_friend_assemblies_3.cs
// compile with: /target:library /keyfile:friend_assemblies.snk
using System.Runtime.CompilerServices;

[assembly:InternalsVisibleTo("cs_friend_assemblies_4, PublicKey=0024000004800000940000000602000000240000525341310004000001000100031d7b6f3abc16c7de526fd67ec2926fe68ed2f9901afbc5f1b6b428bf6cd9086021a0b38b76bc340dc6ab27b65e4a593fa0e60689ac98dd71a12248ca025751d135df7b98c5f9d09172f7b62dabdd302b2a1ae688731ff3fc7a6ab9e8cf39fb73c60667e1b071ef7da5838dc009ae0119a9cbff2c581fc0f2d966b77114b2c4")]
class Class1 
{
    public void Test() 
    {
        System.Console.WriteLine("Class1.Test");
    }
}

En este ejemplo se muestra cómo utilizar los tipos y miembros internos que están disponibles para los ensamblados que tienen nombres seguros.

// cs_friend_assemblies_4.cs
// compile with: /keyfile:friend_assemblies.snk /reference:cs_friend_assemblies_3.dll /out:cs_friend_assemblies_4.exe
public class M 
{
    static void Main() 
    {
        Class1 a = new Class1();
        a.Test();
    }
}

Class1.Test

Vea también

Conceptos

Guía de programación de C#

Referencia

Ensamblados y Caché de ensamblados global (Guía de programación de C#)