Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
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# ouFriend
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# ouFriend
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#) ouFriend
(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).