Comparteix a través de

Procedimiento para crear ensamblados de confianza sin firmar

  • Article

En este ejemplo se muestra cómo usar ensamblados de confianza con ensamblados sin firmar.

Creación de un ensamblado y un ensamblado de confianza

  1. Abra un símbolo del sistema.

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

    // 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");
    }
}

    ' friend_unsigned_A.vb
' Compile with:
' vbc -target:library friend_unsigned_A.vb
Imports System.Runtime.CompilerServices

<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

  3. Compile y firme friend_unsigned_A mediante el siguiente comando:

    csc /target:library friend_unsigned_A.cs

    vbc -target:library friend_unsigned_A.vb

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

    // 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();
    }
}

    ' 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

  5. Compile friend_unsigned_B mediante el siguiente comando.

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

    vbc -r:friend_unsigned_A.dll friend_unsigned_B.vb

    El nombre del ensamblado que genera el compilador debe coincidir con el nombre del ensamblado de confianza que se ha pasado al atributo InternalsVisibleToAttribute. Debe especificar explícitamente el nombre del ensamblado de salida ( .exe o .dll) mediante la opción -out del compilador. Para obtener más información, vea OutputAssembly (Opciones del compilador de C#) o -out (Visual Basic).

  6. Ejecute el archivo friend_unsigned_B.exe.

    El programa genera dos cadenas: Class1.Test y Class2.Test.

Seguridad de .NET

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

Vea también