Cómo: Crear ensamblados de confianza sin firmar (C# y Visual Basic)

En este ejemplo se muestra cómo usar los ensamblados de confianza con los ensamblados no firmados.

Para crear un ensamblado y un ensamblado de confianza en Visual Studio

1. Abra un símbolo del sistema de Visual Studio.

2. Cree un archivo de Visual Basic o C# denominado friend_signed_A que contenga el siguiente código. El código utiliza el atributo InternalsVisibleToAttribute para declarar friend_signed_B como ensamblado de confianza.

   ' friend_unsigned_A.vb 
   ' Compile with:  
   ' Vbc /target:library friend_unsigned_A.vb 
   Imports System.Runtime.CompilerServices
   Imports System
   
   <Assembly: InternalsVisibleTo("friend_unsigned_B")> 
   
   ' Friend type. 
   Friend Class Class1
       Public Sub Test()
           Console.WriteLine("Class1.Test")
       End Sub 
   End Class 
   
   ' Public type with Friend member. 
   Public Class Class2
       Friend Sub Test()
           Console.WriteLine("Class2.Test")
       End Sub 
   End Class
   

   // friend_unsigned_A.cs 
   // Compile with:  
   // csc /target:library friend_unsigned_A.cs 
   using System.Runtime.CompilerServices;
   using System;
   
   [assembly: InternalsVisibleTo("friend_unsigned_B")]
   
   // Type is 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");
       }
   }
   

3. Compile y firme friend_signed_A mediante el siguiente comando.

   Vbc /target:library friend_unsigned_A.vb
   

   csc /target:library friend_unsigned_A.cs
   

4. Cree un archivo de Visual Basic o C# denominado friend_unsigned_B que contenga el siguiente código. Dado que friend_unsigned_A especifica que friend_unsigned_B es un ensamblado de confianza, el código de friend_unsigned_B puede obtener acceso a los tipos y miembros de Friend (Visual Basic) o internal (C#) de friend_unsigned_A.

   ' friend_unsigned_B.vb 
   ' Compile with:  
   ' Vbc /r:friend_unsigned_A.dll friend_unsigned_B.vb 
   Module Module1
       Sub Main()
           ' Access a Friend type. 
           Dim inst1 As New Class1()
           inst1.Test()
   
           Dim inst2 As New Class2()
           ' Access a Friend member of a public type.
           inst2.Test()
   
           System.Console.ReadLine()
       End Sub 
   End Module
   

   // friend_unsigned_B.cs 
   // Compile with:  
   // csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs 
   public class Program
   {
       static void Main()
       {
           // Access an internal type.
           Class1 inst1 = new Class1();
           inst1.Test();
   
           Class2 inst2 = new Class2();
           // Access an internal member of a public type.
           inst2.Test();
   
           System.Console.ReadLine();
       }
   }
   

5. Compile friend_signed_B mediante el siguiente comando.

   Vbc /r:friend_unsigned_A.dll friend_unsigned_B.vb
   

   csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs
   

   El nombre del ensamblado generado por el compilador debe coincidir con el nombre del ensamblado de confianza que se pasa al atributo InternalsVisibleToAttribute. Puede establecer explícitamente el ensamblado utilizando la opción del compilador /out.

   En C#, debe especificar explícitamente el nombre del ensamblado de salida (.exe o .dll) mediante la opción del compilador /out. En Visual Basic, esto es opcional. Para obtener más información, vea /out (Visual Basic) y /out (Opciones del compilador de C#).

6. Ejecute el archivo friend_signed_B.exe.

   El programa imprime dos cadenas: "Class1.Test" y "Class2.Test".

Seguridad

Hay similitudes entre el atributo InternalsVisibleToAttribute y la clase StrongNameIdentityPermission. La principal diferencia reside en que StrongNameIdentityPermission puede exigir permisos de seguridad para ejecutar una sección de código concreta, mientras que el atributo InternalsVisibleToAttribute controla la visibilidad de los tipos y miembros de Friend (Visual Basic) o internal (C#).

Vea también

Tareas

Cómo: Crear ensamblados de confianza firmados (C# y Visual Basic)

Referencia

InternalsVisibleToAttribute

Conceptos

Ensamblados y caché global de ensamblados (C# y Visual Basic)

Ensamblados de confianza (C# y Visual Basic)

Guía de programación de C#

Otros recursos

Guía de programación en Visual Basic