Montagens de amigos (C++)

Para tempos de execução aplicáveis, o recurso de linguagem de assemblies friend torna os tipos que estão no escopo do namespace ou no escopo global em um componente de assembly acessíveis a um ou mais assemblies de cliente ou .netmodules.

Todos os tempos de execução

Observações

(Este recurso de idioma não é suportado em todos os tempos de execução.)

Tempo de Execução do Windows

Observações

(Este recurso de idioma não é suportado no Tempo de Execução do Windows.)

Requerimentos

Opção do compilador: /ZW

Ambiente de Execução de Linguagem Comum

Observações

Para tornar os tipos no escopo do namespace ou no escopo global de um componente de assemblagem acessíveis a um .netmodule ou a um assembly cliente

1. No componente, especifique um atributo de assembly InternalsVisibleToAttribute e forneça o nome do assembly cliente ou do .netmodule que acessará tipos no componente, seja no escopo do namespace ou no escopo global. Você pode especificar vários assemblies de cliente ou .netmodules especificando atributos adicionais.

2. No assembly do cliente ou .netmodule, ao referenciar o assembly do componente usando #using, passe o atributo as_friend. Se especificar o atributo as_friend para um assembly que não especifique InternalsVisibleToAttribute, ocorrerá uma exceção em runtime se tentar aceder a um tipo no escopo do namespace ou no escopo global no componente.

Um erro de compilação resultará se o assembly que contém o InternalsVisibleToAttribute atributo não tiver um nome forte, mas o assembly cliente que usa o as_friend atributo tiver.

Embora os tipos no escopo do namespace e no escopo global possam ser acessíveis a um assembly de cliente ou .netmodule, a acessibilidade dos membros continua a ser relevante. Por exemplo, você não pode acessar um membro privado.

O acesso a todos os tipos em um assembly deve ser explicitamente concedido. Por exemplo, o conjunto C não tem acesso a todos os tipos no conjunto A se o conjunto C fizer referência ao conjunto B e o conjunto B tiver acesso a todos os tipos no conjunto A.

Para obter informações sobre como assinar, ou seja, como dar um nome forte a um assembly criado usando o compilador Microsoft C++, consulte Strong Name Assemblies (Assembly Signing) (C++/CLI).

Como alternativa ao uso do recurso de assemblies de amigos, você pode usar StrongNameIdentityPermission para restringir o acesso a tipos individuais.

Requerimentos

Opção do compilador: /clr

Exemplos

O exemplo de código a seguir define um componente que especifica uma biblioteca de cliente que tem acesso aos tipos deste componente.

// friend_assemblies.cpp
// compile by using: /clr /LD
using namespace System::Runtime::CompilerServices;
using namespace System;
// an assembly attribute, not bound to a type
[assembly:InternalsVisibleTo("friend_assemblies_2")];

ref class Class1 {
public:
   void Test_Public() {
      Console::WriteLine("Class1::Test_Public");
   }
};

O próximo exemplo de código acessa um tipo privado no componente.

// friend_assemblies_2.cpp
// compile by using: /clr
#using "friend_assemblies.dll" as_friend

int main() {
   Class1 ^ a = gcnew Class1;
   a->Test_Public();
}

Class1::Test_Public

O próximo exemplo de código define um componente, mas não especifica um assembly de cliente que terá acesso aos tipos no componente.

Observe que o componente está vinculado usando /opt:noref. Isso garante que tipos privados sejam emitidos nos metadados do componente, o que não é necessário quando o InternalsVisibleTo atributo está presente. Para obter mais informações, consulte /OPT (Otimizações).

// friend_assemblies_3.cpp
// compile by using: /clr /LD /link /opt:noref
using namespace System;

ref class Class1 {
public:
   void Test_Public() {
      Console::WriteLine("Class1::Test_Public");
   }
};

O exemplo de código a seguir define um cliente que tenta acessar um tipo privado em um componente que não dá acesso aos seus tipos privados. Devido ao comportamento do tempo de execução, se você quiser capturar a exceção, você deve tentar acessar um tipo privado em uma função auxiliar.

// friend_assemblies_4.cpp
// compile by using: /clr
#using "friend_assemblies_3.dll" as_friend
using namespace System;

void Test() {
   Class1 ^ a = gcnew Class1;
}

int main() {
   // to catch this kind of exception, use a helper function
   try {
      Test();
   }
   catch(MethodAccessException ^ e) {
      Console::WriteLine("caught an exception");
   }
}

caught an exception

O próximo exemplo de código mostra como criar um componente de nome forte que especifica uma assemblagem cliente que terá acesso aos tipos dentro do componente.

// friend_assemblies_5.cpp
// compile by using: /clr /LD /link /keyfile:friend_assemblies.snk
using namespace System::Runtime::CompilerServices;
using namespace System;
// an assembly attribute, not bound to a type

[assembly:InternalsVisibleTo("friend_assemblies_6, PublicKey=00240000048000009400000006020000002400005253413100040000010001000bf45d77fd991f3bff0ef51af48a12d35699e04616f27ba561195a69ebd3449c345389dc9603d65be8cd1987bc7ea48bdda35ac7d57d3d82c666b7fc1a5b79836d139ef0ac8c4e715434211660f481612771a9f7059b9b742c3d8af00e01716ed4b872e6f1be0e94863eb5745224f0deaba5b137624d7049b6f2d87fba639fc5")];

private ref class Class1 {
public:
   void Test_Public() {
      Console::WriteLine("Class1::Test_Public");
   }
};

Observe que o componente deve especificar sua chave pública. Sugerimos que você execute os seguintes comandos sequencialmente em um prompt de comando para criar um par de chaves e obter a chave pública:

SN -d friend_assemblies.snk

SN -k friend_assemblies.snk

SN -i friend_assemblies.snk friend_assemblies.snk

sn -pc friend_assemblies.snk chave.publickey

sn -tp key.publickey

O próximo exemplo de código acessa um tipo privado em componente com nome forte.

// friend_assemblies_6.cpp
// compile by using: /clr /link /keyfile:friend_assemblies.snk
#using "friend_assemblies_5.dll" as_friend

int main() {
   Class1 ^ a = gcnew Class1;
   a->Test_Public();
}

Class1::Test_Public

Ver também

Extensões de Componentes para Plataformas de Execução