Partager via

Assemblys friend

  • Article

Un assembly friend est un assembly qui peut accéder aux types et membres internes en C#, ou Friend en Visual Basic d’un autre assembly. Si vous ajoutez un attribut d’assembly à AssemblyA pour identifier AssemblyB en tant qu’assembly friend, vous n’avez plus besoin de marquer les types et les membres dans AssemblyA comme publics pour qu’ils soient accessibles par AssemblyB. Ceci est particulièrement utile dans les scénarios suivants :

  • Pendant un test unitaire, lorsque le code de test s’exécute dans un assembly séparé, mais nécessite l’accès aux membres de l’assembly actuellement testés qui sont marqués comme internal en C# ou Friend en Visual Basic.

  • Lorsque vous développez une bibliothèque de classes et que des ajouts à la bibliothèque sont contenus dans des assemblys séparés, mais nécessitent l’accès aux membres des assemblys existants qui sont marqués comme internal en C# ou Friend en Visual Basic.

Notes

Vous pouvez utiliser l’attribut InternalsVisibleToAttribute pour identifier un ou plusieurs assemblys friend pour un assembly donné. L’exemple suivant utilise l’attribut InternalsVisibleToAttribute dans Assembly A et spécifie l’assembly AssemblyB comme assembly friend. De cette façon, l’assembly AssemblyB a accès à tous les types et membres d’AssemblyA qui sont marqués comme internal en C# ou Friend en Visual Basic.

Remarque

Lorsque vous compilez un assembly comme AssemblyB qui doit accéder aux types ou aux membres internes d’un autre assembly comme AssemblyA, vous devez spécifier explicitement le nom du fichier de sortie (.exe ou .dll) à l’aide de l’option -out du compilateur. Ceci est nécessaire, car le compilateur n’a pas encore généré le nom de l’assembly qu’il est en train de créer au moment où il effectue une liaison avec les références externes. Pour plus d’informations, consultez OutputAssembly (C#) ou -out (Visual Basic).

using System.Runtime.CompilerServices;
using System;

[assembly: InternalsVisibleTo("AssemblyB")]

// The class is internal by default.
class FriendClass
{
    public void Test()
    {
        Console.WriteLine("Sample Class");
    }
}

// Public class that has an internal method.
public class ClassWithFriendMethod
{
    internal void Test()
    {
        Console.WriteLine("Sample Method");
    }

}

Imports System.Runtime.CompilerServices
<Assembly: InternalsVisibleTo("AssemblyB")>

' Friend class.
Friend Class FriendClass
    Public Sub Test()
        Console.WriteLine("Sample Class")
    End Sub
End Class

' Public class with a Friend method.
Public Class ClassWithFriendMethod
    Friend Sub Test()
        Console.WriteLine("Sample Method")
    End Sub
End Class

Seuls les assemblys que vous spécifiez explicitement, comme les assemblys friend, peuvent accéder aux types et aux membres internal (C#) ou Friend (Visual Basic). Par exemple, si AssemblyB est un assembly friend d’AssemblyA et que AssemblyC fait référence ç AssemblyB, Assembly C n’a pas accès aux types internal (C#) ou Friend (Visual Basic) dans AssemblyA.

Le compilateur effectue une validation de base du nom de l’assembly friend soumis à l’attribut InternalsVisibleToAttribute. Si AssemblyA déclare AssemblyB comme étant un assembly friend, les règles de validation sont les suivantes :

  • Si AssemblyA porte un nom fort, AssemblyB doit également porter un nom fort. Le nom de l’assembly friend qui est passé à l’attribut doit être composé du nom de l’assembly et de la clé publique de la clé de nom fort qui est utilisée pour signer AssemblyB.

    Le nom de l’assembly friend soumis à l’attribut InternalsVisibleToAttribute ne peut pas être le nom fort d’AssemblyB. N’incluez pas la version de l’assembly, la culture, l’architecture ou le jeton de clé publique.

  • Si l’assembly A n’a pas un nom fort, le nom de l’assembly friend doit être constitué uniquement du nom de l’assembly. Pour plus d’informations, consultez Guide pratique pour créer des assemblys friend non signés.

  • Si AssemblyB porte un nom fort, vous devez spécifier la clé de nom fort d’AssemblyB en utilisant le paramètre de projet ou l’option de compilateur /keyfile. Pour plus d’informations, consultez Guide pratique pour créer des assemblys friend signés.

La classe StrongNameIdentityPermission offre également la possibilité de partager des types, avec les différences suivantes :

  • StrongNameIdentityPermission s’applique à un type individuel, alors qu’un assembly friend s’applique à l’assembly entier.

  • Si vous souhaitez partager des centaines de types d’Assembly avec AssemblyB, vous devez ajouter StrongNameIdentityPermission à chacun d’eux. Si vous utilisez un assembly friend, vous n’aurez à déclarer la relation d’assembly friend qu’une seule fois.

  • Si vous utilisez StrongNameIdentityPermission, les types que vous voulez partager doivent être déclarés comme publics. Si vous utilisez un assembly friend, les types partagés sont déclarés comme internal (C#) ou Friend (Visual Basic).

Pour plus d’informations sur la façon d’accéder aux types et aux méthodes internal (C#) ou Friend (Visual Basic) d’un assembly à partir d’un fichier de module (avec l’extension .netmodule), consultez ModuleAssemblyName (C#) ou -moduleassemblyname (Visual Basic).

Voir aussi