Assemblys friend (Guide de programmation C#)

Mise à jour : novembre 2007

Un type ou un membre interne d'un assembly est accessible depuis un autre assembly.

Notes

La fonctionnalité d'assemblys friend vous permet d'accéder aux membres internes ; les types privés et les membres privés restent inaccessibles.

Pour donner à un assembly (assembly B) l'accès aux types et membres internes d'un autre assembly (assembly A), utilisez l'attribut InternalsVisibleToAttribute dans l'assembly A.

Remarque :

Lorsque vous compilez un assembly (assembly B) qui doit accéder à des types ou des membres internes d'un autre assembly (assembly A), vous devez spécifier explicitement le nom du fichier de sortie (.exe ou .dll) avec l'option du compilateur /out (pour plus d'informations, consultez /out). Cela est obligatoire parce que le compilateur n'a pas encore généré le nom de l'assembly qu'il génère au moment de la liaison avec des références externes.

La classe StrongNameIdentityPermission offre également la capacité 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 l'assembly A contient des centaines de types que vous voulez partager avec l'assembly B, vous devez les décorer tous avec StrongNameIdentityPermission, alors qu'avec un assembly friend, il vous suffit de déclarer une fois pour toutes la relation "friend".

• Avec StrongNameIdentityPermission, les types que vous voulez partager doivent être déclarés comme publics. Avec un assembly friend, les types partagés sont déclarés comme internes.

• Pour plus d'informations sur la manière de construire un .netmodule capable d'accéder aux types non publics d'un assembly, consultez /moduleassemblyname.

Exemple

Dans cet exemple, l'assembly rend des types et des membres internes visibles à l'assembly appelé cs_friend_assemblies_2.

// cs_friend_assemblies.cs
// compile with: /target:library
using System.Runtime.CompilerServices;
using System;

[assembly:InternalsVisibleTo("cs_friend_assemblies_2")]

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

Dans cet exemple, l'assembly consomme des types et des membres internes dans l'assembly cs_friend_assemblies.dll.

Remarquez que vous devez spécifier explicitement le nom du fichier de sortie (/out:cs_friend_assemblies_2.exe).

Si cet assembly donne à un autre assembly (assembly C) l'accès à ses types et membres internes, l'assembly C ne devient pas automatiquement une fonction friend d'assembly cs_friend_assemblies.dll.

// cs_friend_assemblies_2.cs
// compile with: /reference:cs_friend_assemblies.dll /out:cs_friend_assemblies_2.exe
public class M 
{
    static void Main() 
    {
        // access an internal type
        Class1 a = new Class1();
        a.Test();

        Class2 b = new Class2();
        // access an internal member of a public type
        b.Test();
    }
}

Class1.Test
Class2.Test

Cet exemple indique comment rendre des types et des membres internes disponibles pour les assemblys qui ont des noms forts.

Pour générer le fichier de clé et afficher la clé publique, utilisez la séquence suivante de commandes sn.exe (pour plus d'informations, consultez Outil Strong Name Tool (Sn.exe)) :

• sn -k friend_assemblies.snk // Générez la clé de nom fort

• sn -p friend_assemblies.snk key.publickey // Extrayez la clé publique de key.snk dans key.publickey

• sn -tp key.publickey // Affichez la clé publique stockée dans le fichier 'key.publickey

Passez le fichier de clé au compilateur avec /keyfile.

// cs_friend_assemblies_3.cs
// compile with: /target:library /keyfile:friend_assemblies.snk
using System.Runtime.CompilerServices;

[assembly:InternalsVisibleTo("cs_friend_assemblies_4, PublicKey=0024000004800000940000000602000000240000525341310004000001000100031d7b6f3abc16c7de526fd67ec2926fe68ed2f9901afbc5f1b6b428bf6cd9086021a0b38b76bc340dc6ab27b65e4a593fa0e60689ac98dd71a12248ca025751d135df7b98c5f9d09172f7b62dabdd302b2a1ae688731ff3fc7a6ab9e8cf39fb73c60667e1b071ef7da5838dc009ae0119a9cbff2c581fc0f2d966b77114b2c4")]
class Class1 
{
    public void Test() 
    {
        System.Console.WriteLine("Class1.Test");
    }
}

Cet exemple indique comment consommer des types et des membres internes disponibles pour les assemblys qui ont des noms forts.

// cs_friend_assemblies_4.cs
// compile with: /keyfile:friend_assemblies.snk /reference:cs_friend_assemblies_3.dll /out:cs_friend_assemblies_4.exe
public class M 
{
    static void Main() 
    {
        Class1 a = new Class1();
        a.Test();
    }
}

Class1.Test

Voir aussi

Concepts

Guide de programmation C#

Référence

Assemblys et le Global Assembly Cache (Guide de programmation C#)