Partager via

Assemblys friend

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 ami, vous n’avez plus besoin de marquer les types et les membres dans AssemblyA comme publics pour qu’ils soient accessibles par AssemblyB. Cela est particulièrement pratique dans les scénarios suivants :

  • Pendant les tests unitaires, lorsque le code de test s’exécute dans un assembly distinct, mais nécessite l’accès aux membres de l’assembly en cours de test 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 assemblages distincts, mais que vous avez besoin d'accéder aux membres de ceux des assemblages existants marqués par internal en C# ou Friend en Visual Basic.

Remarques

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 AssemblyA et spécifie assemblyB comme assembly friend. Cela permet à assembly AssemblyB d’accéder à tous les types et membres de l’assembly A marqués comme internal C# ou Friend en Visual Basic.

Remarque

Lorsque vous compilez un assembly comme AssemblyB qui accède aux types internes 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 du compilateur -out . Cela est nécessaire, car le compilateur n’a pas encore généré le nom de l’assembly qu’il génère au moment où il est associé à des 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 assemblages que vous spécifiez explicitement comme amis peuvent accéder aux types et membres internal (C#) ou Friend (Visual Basic). Par exemple, si AssemblyB est un ami d’Assembly A et assembly C fait référence à AssemblyB, Assembly C n’a pas accès aux internal types (C#) ou Friend (Visual Basic) dans Assembly A.

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

  • Si l’assembly A est signé avec un nom fort, AssemblyB doit également être signé avec un nom fort. Le nom d’assemblage ami transmis à l’attribut doit être constitué du nom d’assemblage et de la clé publique de la clé de nom fort utilisée pour signer AssemblyB.

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

  • Si l’assembly A n’a pas de nom fort, le nom de l’assembly ami doit être constitué uniquement du nom de l’assembly. Pour plus d’informations, consultez Comment créer des assemblies amis non signés.

  • Si AssemblyB a un nom fort, vous devez spécifier la clé de nom fort pour AssemblyB à l’aide du paramètre de projet ou de l’option de ligne de commande du compilateur /keyfile. Pour plus d'informations, consultez Comment : Créer des assemblées amies signées.

La StrongNameIdentityPermission classe 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.

  • S’il existe des centaines de types dans Assembly A que vous souhaitez partager avec AssemblyB, vous devez les ajouter StrongNameIdentityPermission à tous. 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 souhaitez partager doivent être déclarés en tant que publics. Si vous utilisez un assembly friend, les types partagés sont déclarés en tant que internal (C#) ou Friend (Visual Basic).

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

Voir aussi