Partilhar via

Assembleias de amigos

Um assembly friend é um assembly que pode aceder aos tipos e membros internos (C#) ou Friend (Visual Basic) de outro assembly. Se você adicionar um atributo assembly a AssemblyA para identificar AssemblyB como um assembly amigo, não será mais necessário marcar tipos e membros em AssemblyA como públicos para que eles sejam acessados por AssemblyB. Isso é especialmente conveniente nos seguintes cenários:

  • Durante o teste de unidade, quando o código de teste é executado num assembly separado, mas requer acesso aos membros do assembly que está sendo testado e que estão marcados como internal em C# ou Friend no Visual Basic.

  • Quando você está desenvolvendo uma biblioteca de classes e adições à biblioteca estão contidas em assemblies separados, mas exigem acesso a membros em assemblies existentes que são marcados como internal em C# ou Friend no Visual Basic.

Observações

Pode usar o atributo InternalsVisibleToAttribute para identificar uma ou mais assemblies relacionadas para um determinado assembly. O exemplo a seguir usa o InternalsVisibleToAttribute atributo em AssemblyA e especifica assembly AssemblyB como um assembly amigo. Isso dá ao assembly AssemblyB acesso a todos os tipos e membros no Assembly A marcados como internal em C# ou Friend no Visual Basic.

Observação

Quando você compila um assembly como AssemblyB que acessará tipos internos ou membros internos de outro assembly como AssemblyA, você deve especificar explicitamente o nome do arquivo de saída (.exe ou .dll) usando a opção de compilador -out . Isso é necessário porque o compilador ainda não gerou o nome para o assembly que está construindo no momento em que está vinculando a referências externas. Para obter mais informações, consulte 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

Somente os assemblies que especificares explicitamente como amigos podem acessar tipos e membros internal (C#) ou Friend (Visual Basic). Por exemplo, se AssemblyB é amigo do Assembly A e Assembly C faz referência a AssemblyB, Assembly C não tem acesso a internal tipos (C#) ou Friend (Visual Basic) no Assembly A.

O compilador executa alguma validação básica do nome do assembly amigo passado para o atributo InternalsVisibleToAttribute. Se o Assembly A declarar AssemblyB como um assembly amigo, as regras de validação serão as seguintes:

  • Se Assembly A tiver um nome forte, AssemblyB também deve ter um nome forte. O nome do assembly amigo que é passado para o atributo deve consistir no nome do assembly e na chave pública da chave strong-name usada para assinar AssemblyB.

    O nome do assembly amigo que é passado para o InternalsVisibleToAttribute atributo não pode ser o nome forte de AssemblyB. Não inclua a versão de montagem, a cultura, a arquitetura ou o token de chave pública.

  • Se Assembly A não tiver um nome forte, o nome da friend assembly deverá consistir apenas no nome do assembly. Para obter mais informações, consulte Como criar assemblies de amigos não assinados.

  • Se AssemblyB estiver com nome forte, você deverá especificar a chave de nome forte para AssemblyB usando a configuração do projeto ou a opção de compilador da linha de comando /keyfile. Para obter mais informações, consulte Como criar assemblies de amigos assinados.

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

  • StrongNameIdentityPermission aplica-se a um tipo individual, enquanto uma montagem amiga se aplica a toda a montagem.

  • Se houver centenas de tipos no Assembly A que você deseja compartilhar com o AssemblyB, você terá que adicionar StrongNameIdentityPermission a todos eles. Se você usar uma assembleia de amigos, você só precisa declarar a relação de amizade uma vez.

  • Se utilizar StrongNameIdentityPermission, os tipos que pretende partilhar têm de ser declarados públicos. Se utilizar um assembly amigo, os tipos compartilhados serão declarados como internal (C#) ou Friend (Visual Basic).

Para obter informações sobre como acessar os internal tipos e métodos de um assembly (C#) ou Friend (Visual Basic) a partir de um arquivo de módulo (um arquivo com a extensão .netmodule ), consulte ModuleAssemblyName (C#) ou -moduleassemblyname (Visual Basic).

Ver também