Assemblys friend (C++)Friend Assemblies (C++)

Pour les runtimes applicables, la fonctionnalité de langage des assemblys friend rend les types situés au niveau de la portée espace de noms ou de la portée globale dans un composant d’assembly accessible à un ou plusieurs assemblys client ou. netmodule.For applicable runtimes, the friend assemblies language feature makes types that are at namespace scope or global scope in an assembly component accessible to one or more client assemblies or .netmodules.

Tous les runtimesAll Runtimes

RemarquesRemarks

(Cette fonctionnalité de langage n’est pas prise en charge dans tous les runtimes.)(This language feature is not supported in all runtimes.)

Windows RuntimeWindows Runtime

RemarquesRemarks

(Cette fonctionnalité de langage n’est pas prise en charge dans Windows Runtime.)(This language feature is not supported in the Windows Runtime.)

SpécificationsRequirements

Option du compilateur : /ZWCompiler option: /ZW

Common Language RuntimeCommon Language Runtime

RemarquesRemarks

Pour créer des types au niveau de la portée espace de noms ou de la portée globale dans un composant d’assembly accessible à un assembly client ou un. netmoduleTo make types at namespace scope or global scope in an assembly component accessible to a client assembly or .netmodule

  1. Dans le composant, spécifiez un attribut d’assembly InternalsVisibleToAttribute et transmettez le nom de l’assembly client ou du. netmodule qui accédera aux types au niveau de la portée de l’espace de noms ou de la portée globale dans le composant.In the component, specify an assembly attribute InternalsVisibleToAttribute, and pass the name of the client assembly or .netmodule that will access types at namespace scope or global scope in the component. Vous pouvez spécifier plusieurs assemblys client ou. netmodule en spécifiant des attributs supplémentaires.You can specify multiple client assemblies or .netmodules by specifying additional attributes.

  2. Dans l’assembly client ou. netmodule, lorsque vous référencez l’assembly de composant à l’aide de #using , transmettez l' as_friend attribut.In the client assembly or .netmodule, when you reference the component assembly by using #using, pass the as_friend attribute. Si vous spécifiez l' as_friend attribut d’un assembly qui ne spécifie pas InternalsVisibleToAttribute , une exception Runtime est levée si vous essayez d’accéder à un type au niveau de la portée de l’espace de noms ou de la portée globale dans le composant.If you specify the as_friend attribute for an assembly that does not specify InternalsVisibleToAttribute, a runtime exception will be thrown if you try to access a type at namespace scope or global scope in the component.

Une erreur de build se produit si l’assembly qui contient l' InternalsVisibleToAttribute attribut n’a pas de nom fort, mais que l’assembly client qui utilise l' as_friend attribut.A build error will result if the assembly that contains the InternalsVisibleToAttribute attribute does not have a strong name but the client assembly that uses the as_friend attribute does.

Bien que les types au niveau de la portée de l’espace de noms et de la portée globale puissent être connus d’un assembly client ou. netmodule, l’accessibilité des membres est toujours en vigueur.Although types at namespace scope and global scope can be known to a client assembly or .netmodule, member accessibility is still in effect. Par exemple, vous ne pouvez pas accéder à un membre privé.For example, you cannot access a private member.

L’accès à tous les types dans un assembly doit être accordé explicitement.Access to all types in an assembly must be explicitly granted. Par exemple, l’assembly C n’a pas accès à tous les types de l’assembly A si l’assembly C fait référence à l’assembly B et que l’assembly B a accès à tous les types de l’assembly A.For example, assembly C does not have access to all types in assembly A if assembly C references assembly B and assembly B has access to all types in assembly A.

Pour plus d’informations sur la façon de signer, c’est-à-dire comment attribuer un nom fort, à un assembly créé à l’aide du compilateur Microsoft C++, consultez assemblys de nom fort (signature d’assembly) (C++/CLI).For information about how to sign—that is, how to give a strong name to—an assembly that is built by using the Microsoft C++ compiler, see Strong Name Assemblies (Assembly Signing) (C++/CLI).

Au lieu d’utiliser la fonctionnalité d’assemblys friend, vous pouvez utiliser StrongNameIdentityPermission pour restreindre l’accès aux types individuels.As an alternative to using the friend assemblies feature, you can use StrongNameIdentityPermission to restrict access to individual types.

SpécificationsRequirements

Option du compilateur : /clrCompiler option: /clr

ExemplesExamples

L’exemple de code suivant définit un composant qui spécifie un assembly client qui a accès aux types dans le composant.The following code example defines a component that specifies a client assembly that has access to the types in the component.

// 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");
   }
};

L’exemple de code suivant accède à un type privé dans le composant.The next code example accesses a private type in the component.

// 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

L’exemple de code suivant définit un composant, mais ne spécifie pas un assembly client qui aura accès aux types dans le composant.The next code example defines a component but does not specify a client assembly that will have access to the types in the component.

Notez que le composant est lié à l’aide de /OPT : NOREF.Notice that the component is linked by using /opt:noref. Cela garantit que les types privés sont émis dans les métadonnées du composant, ce qui n’est pas obligatoire lorsque l' InternalsVisibleTo attribut est présent.This ensures that private types are emitted in the component's metadata, which is not required when the InternalsVisibleTo attribute is present. Pour plus d’informations, consultez /OPT (optimisations).For more information, see /OPT (Optimizations).

// 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");
   }
};

L’exemple de code suivant définit un client qui tente d’accéder à un type privé dans un composant qui ne donne pas accès à ses types privés.The following code example defines a client that tries to access a private type in a component that does not give access to its private types. En raison du comportement du runtime, si vous souhaitez intercepter l’exception, vous devez tenter d’accéder à un type privé dans une fonction d’assistance.Because of the behavior of the runtime, if you want to catch the exception, you must attempt to access a private type in a helper function.

// 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

L’exemple de code suivant montre comment créer un composant de nom fort qui spécifie un assembly client qui aura accès aux types dans le composant.The next code example shows how to create a strong-name component that specifies a client assembly that will have access to the types in the component.

// 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");
   }
};

Notez que le composant doit spécifier sa clé publique.Notice that the component must specify its public key. Nous vous suggérons d’exécuter les commandes suivantes séquentiellement à une invite de commandes pour créer une paire de clés et obtenir la clé publique :We suggest that you run the following commands sequentially at a command prompt to create a key pair and get the public key:

SN-d friend_assemblies. snksn -d friend_assemblies.snk

sn-k friend_assemblies. snksn -k friend_assemblies.snk

sn-i friend_assemblies. snk friend_assemblies. snksn -i friend_assemblies.snk friend_assemblies.snk

SN-PC friend_assemblies. snk Key. PublicKeysn -pc friend_assemblies.snk key.publickey

sn -tp key.publickeysn -tp key.publickey

L’exemple de code suivant accède à un type privé dans le composant de nom fort.The next code example accesses a private type in the strong-name component.

// 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

Voir aussiSee also

Extensions de composant pour les plateformes RuntimeComponent Extensions for Runtime Platforms