Compartilhar via

Assemblies amigáveis

  • Artigo

Um assembly amigável é um assembly que pode acessar os membros e tipos internos de outro assembly (C#) ou Amigável (Visual Basic). Se você adicionar um atributo de assembly ao AssemblyA para identificar o AssemblyB como um assembly amigável, não precisará mais marcar tipos e membros no AssemblyA como públicos para que eles sejam acessados pelo AssemblyB. Isso é especialmente conveniente nos seguintes cenários:

  • Durante os testes de unidade, quando o código de teste é executado em um assembly separado, mas exige acesso aos membros do assembly sendo testado que são marcados como internal no C# ou Friend no Visual Basic.

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

Comentários

Você pode usar o atributo InternalsVisibleToAttribute para identificar um ou mais assemblies amigáveis para um determinado assembly. O exemplo a seguir usa o atributo InternalsVisibleToAttribute no AssemblyA e especifica o assembly AssemblyB como um assembly amigável. Isso fornece ao assembly AssemblyB acesso a todos os tipos e membros do Assembly A que são marcados como internal no C# ou Friend no Visual Basic.

Observação

Ao compilar um assembly como o AssemblyB que acessará tipos internos ou membros internos de outro assembly, como o AssemblyA, você deve especificar explicitamente o nome do arquivo de saída (.exe ou .dll) usando a opção do compilador -out. Isso é necessário porque o compilador ainda não gerou o nome do assembly que está compilando no momento em que ele está se associando às referências externas. Para saber mais, confira 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

Apenas os assemblies que você especificar explicitamente como amigáveis podem acessar os membros e os tipos internal (C#) ou Friend (Visual Basic). Por exemplo, se o AssemblyB for amigável para o Assembly A e o Assembly C fizer referência ao AssemblyB, o Assembly C não terá acesso aos tipos internal (C#) ou Friend (Visual Basic) no Assembly A.

O compilador executa algumas validações básicas do nome do assembly amigável passado para o atributo InternalsVisibleToAttribute. Se o Assembly A declara o Assembly B como um assembly amigável, as regras de validação são as seguintes:

  • Se o Assembly A for fortemente nomeado, o Assembly B também deverá ser fortemente nomeado. O nome do assembly amigável passado para o atributo deve consistir no nome do assembly e a chave pública da chave de nome forte usada para assinar o Assembly B.

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

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

  • Se o Assembly B tiver um nome forte, você deverá especificara a chave de nome forte do Assembly B usando a configuração do projeto ou a opção do compilador /keyfile de linha de comando. Para obter mais informações, consulte Como criar assemblies amigáveis assinados.

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

  • StrongNameIdentityPermission aplica-se a um tipo individual, enquanto um assembly amigável se aplica ao assembly inteiro.

  • Se há centenas de tipos no Assembly A que você deseja compartilhar como o Assembly B, é necessário adicionar StrongNameIdentityPermission a todos eles. Se usar um assembly amigável, você precisará declarar a relação de amigo uma vez.

  • Se você usar StrongNameIdentityPermission, os tipos que você desejar compartilhar precisarão ser declarados como públicos. Se você usar um assembly amigável, os tipos compartilhados serão declarados como internal (C#) ou Friend (Visual Basic).

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

Confira também