Friend Assemblies (guia de programação translation from VPE for Csharp)

Um tipo interno ou o membro interno em um assembly pode ser acessado de outro assembly.

Comentários

O recurso de assemblies amigo permite acesso membros internos; particulares tipos e membros privados permanecerá inacessoible.

Para conceder acesso um assembly (conjunto B) a outro do assembly (do assembly) interno tipos e membros, use o InternalsVisibleToAttribute atributo no assembly a.

Observação:

Ao compilar um assembly (conjunto B) que será acesso interna de tipos ou membros internos de outro assembly (um assembly) , Você deve especificar explicitamente o nome do arquivo de saída (.exe ou.DLL ) com o /out (consulte opção do compilador /out para obter mais informações).Isso é necessário porque o compilador não gerou ainda o nome para o assembly que for criado no momento é vincular para referências externas.

The StrongNameIdentityPermission classe também fornece a capacidade de compartilhar tipos, com as seguintes diferenças:

• StrongNameIdentityPermission aplica-se a um tipo individual, enquanto um assembly amigo se aplica ao assembly inteiro.

• Se existirem centenas de tipos no assembly A que você deseja compartilhar com o assembly B, você precisará decorar todas elas com StrongNameIdentityPermission, ao usar um assembly de amigo, você só precisa declarar a relação de amigo uma vez.

• Usando StrongNameIdentityPermission, sistema autônomo tipos que deseja compartilhar precisam ser declarado sistema autônomo público. Usando um conjunto de amigo, tipos compartilhados são declarados sistema autônomo internos.

• Para obter informações sobre como criar um.netmodule pode acessar tipos não-públicos em um assembly, consulte /moduleassemblyname.

Exemplo

Neste exemplo, o assembly torna interna de tipos e membros internos visível ao conjunto de módulos (assembly) denominado 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");
    }
}

Neste exemplo, o assembly consome tipos internos e membros internos no assembly cs_friend_assemblies.dll.

Observe que você deve especificar explicitamente o nome do arquivo de saída (/out:cs_friend_assemblies_2.exe).

Se esse assembly outra montagem (assembly C) acesso a seus membros e tipos internos, o assembly C não fica automaticamente um amigo cs_friend_assemblies.dll assembly.

// 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

Este exemplo mostra como disponibilizar interna de tipos e membros para os assemblies com nomes fortes.

Para gerar a chave de arquivo e exibir a chave pública, use a seguinte sequência de comandos sn.exe (para obter mais informações, consulte Ferramenta Strong Name (Sn.exe)):

• sn -k friend_assemblies.snk / / gerar chave de nome forte

• sn -p friend_assemblies.snk key.publickey / / extrair a chave pública de key.snk em key.publickey

• sn - tp key.publickey / / exibição pública chave armazenada em arquivo'key.publickey

Passe a chave de arquivo para o compilador com /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");
    }
}

Este exemplo mostra como consumir interna de tipos e membros disponível para os assemblies com nomes fortes.

// 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

Consulte também

Conceitos

Guia de Programação C#

Referência

Conjuntos e (guia de programação C#) no cache do conjunto de módulos (assembly) global