Partager via

Guide pratique pour créer des assemblys friend non signés

  • Article

Cet exemple montre comment utiliser des assemblys friend avec des assemblys qui ne sont pas signés.

Créer un assembly et un assembly friend

  1. Ouvrez une invite de commandes.

  2. Créez un fichier C# ou Visual Basic nommé friend_unsigned_A qui contient le code suivant. Le code utilise l’attribut InternalsVisibleToAttribute pour déclarer friend_unsigned_B comme assembly friend.

    // 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. Compilez et signez friend_unsigned_A à l’aide de la commande suivante :

    csc /target:library friend_unsigned_A.cs

    vbc -target:library friend_unsigned_A.vb

  4. Créez un fichier C# ou Visual Basic nommé friend_unsigned_B qui contient le code suivant. Étant donné que friend_unsigned_A spécifie friend_unsigned_Bcomme assembly friend, le code dans friend_unsigned_B peut accéder aux membres et aux types internal (C#) ou Friend (Visual Basic) de 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. Compilez friend_unsigned_B avec la commande suivante.

    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

    Le nom de l’assembly qui est généré par le compilateur doit correspondre au nom de l’assembly friend qui est passé à l’attribut InternalsVisibleToAttribute. Vous devez spécifier explicitement le nom de l’assembly de sortie (.exe ou .dll) en utilisant l’option -out du compilateur. Pour plus d’informations, consultez OutputAssembly (options du compilateur C#) ou -out (Visual Basic).

  6. Exécutez le fichier friend_unsigned_B.exe.

    Le programme génère deux chaînes : Class1.Test et Class2.Test.

Sécurité .NET

Il existe des similitudes entre l’attribut InternalsVisibleToAttribute et la classe StrongNameIdentityPermission. La principale différence est que StrongNameIdentityPermission peut demander des autorisations de sécurité pour exécuter une section de code particulière, tandis que l’attribut InternalsVisibleToAttribute contrôle la visibilité des membres et des types internal ou Friend (Visual Basic).

Voir aussi