Partilhar via

Assembleias de amigos

  • Artigo

Um assembly friend é um assembly que pode acessar os 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 em um assembly separado, mas requer acesso aos membros no assembly que está sendo testado 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

Você pode usar o InternalsVisibleToAttribute atributo para identificar um ou mais assemblies amigos 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.

Nota

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 assemblies que você especificar explicitamente como amigos podem acessar internal tipos e membros (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 InternalsVisibleToAttribute atributo. Se o Assembly A declarar AssemblyB como um assembly amigo, as regras de validação serão as seguintes:

  • Se Assembly A é strong named, AssemblyB também deve ser strong named. 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 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 amigo deverá consistir apenas no nome do assembly. Para obter mais informações, consulte Como criar assemblies de amigos não assinados.

  • Se AssemblyB for strong named, você deverá especificar a chave strong-name para AssemblyB usando a configuração do projeto ou a opção de compilador de linha /keyfile de comando. 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 StrongNameIdentityPermissiono , os tipos que pretende partilhar têm de ser declarados como públicos. Se você usar 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).

Consulte também