#using directive (C++/CLI)#using directive (C++/CLI)

Importe des métadonnées dans un programme compilé avec /CLR.Imports metadata into a program compiled with /clr.

SyntaxeSyntax

#using fichier [as_friend]#using file [as_friend]

ParamètresParameters

txtfile
MSIL .dll, .exe, .netmodule ou .obj. Par exemple,An MSIL .dll, .exe, .netmodule, or .obj. For example,

#using <MyComponent.dll>

as_friendas_friend
Spécifie que tous les types dans le fichier sont accessibles.Specifies that all types in file are accessible. Pour plus d’informations, consultez assemblys friendC++().For more information, see Friend Assemblies (C++).

NotesRemarks

le fichier peut être un fichier MSIL (Microsoft Intermediate Language) que vous importez pour ses données managées et les constructions managées.file can be a Microsoft intermediate language (MSIL) file that you import for its managed data and managed constructs. Si un fichier. dll contient un manifeste d’assembly, toutes les fichiers. dll référencés dans le manifeste sont importés et l’assembly que vous générez répertorie les fichiers dans les métadonnées sous la forme d’une référence d’assembly.If a .dll file contains an assembly manifest, then all the .dlls referenced in the manifest are imported and the assembly you are building will list file in the metadata as an assembly reference.

Si le fichier ne contient pas d’assembly (si le fichier est un module) et si vous n’envisagez pas d’utiliser les informations de type du module dans l’application (Assembly) actuelle, vous avez la possibilité de simplement indiquer que le module fait partie de l’assembly. Utilisez /ASSEMBLYMODULE.If file does not contain an assembly (if file is a module) and if you do not intend to use type information from the module in the current (assembly) application, you have the option of just indicating that the module is part the assembly; use /ASSEMBLYMODULE. Les types du module sont ensuite accessibles à toute application qui a référencé l'assembly.The types in the module would then be available to any application that referenced the assembly.

Une alternative à l’utilisation de #using est l’option de compilateur /Fu .An alternative to use #using is the /FU compiler option.

les assemblys. exe passés à #using doivent être compilés à l’aide de l’un des compilateurs Visual Studio .net ( C#Visual Basic ou visuel, par exemple)..exe assemblies passed to #using should be compiled by using one of the .NET Visual Studio compilers (Visual Basic or Visual C#, for example). Toute tentative d'importation des métadonnées à partir d'un assembly .exe compilé avec /clr provoque une exception de chargement du fichier.Attempting to import metadata from an .exe assembly compiled with /clr will result in a file load exception.

Notes

Un composant référencé avec #using peut être exécuté avec une version différente du fichier importé au moment de la compilation, ce qui entraîne une application cliente qui donne des résultats inattendus.A component that is referenced with #using can be run with a different version of the file imported at compile time, causing a client application to give unexpected results.

Pour que le compilateur reconnaisse un type dans un assembly (et non un module), il doit être forcé de résoudre le type.In order for the compiler to recognize a type in an assembly (not a module), it needs to be forced to resolve the type. Vous pouvez le forcer, par exemple, en définissant une instance du type.You can force it, for example, by defining an instance of the type. Il existe d’autres façons de résoudre les noms de types dans un assembly pour le compilateur.There are other ways to resolve type names in an assembly for the compiler. Par exemple, si vous héritez d’un type dans un assembly, le nom de type devient connu du compilateur.For example, if you inherit from a type in an assembly, the type name becomes known to the compiler.

Lors de l’importation de métadonnées générées à partir du code source qui utilisait _ _ declspec (thread), la sémantique des threads n’est pas conservée dans les métadonnées.When importing metadata built from source code that used __declspec(thread), the thread semantics aren't persisted in metadata. Par exemple, une variable déclarée avec _ _ declspec (thread) , compilée dans un programme généré pour la .NET Framework Common Language Runtime, puis importée via #using, n’aura pas de sémantique _ _ declspec (thread) sur la variable.For example, a variable declared with __declspec(thread), compiled in a program that is built for the .NET Framework common language runtime, and then imported via #using, won't have __declspec(thread) semantics on the variable.

Tous les types importés (managés et natifs) dans un fichier référencé par #using sont disponibles, mais le compilateur traite les types natifs comme des déclarations, et non des définitions.All imported types (both managed and native) in a file referenced by #using are available, but the compiler treats native types as declarations, not definitions.

mscorlib.dll est automatiquement référencé lors de la compilation avec /clr.mscorlib.dll is automatically referenced when compiling with /clr.

La variable d’environnement LIBPATH spécifie les répertoires à rechercher lorsque le compilateur résout les noms de fichiers passés à #using.The LIBPATH environment variable specifies the directories to search when the compiler resolves file names passed to #using.

Le compilateur recherche des références le long du chemin suivant:The compiler searches for references along the following path:

  • Chemin d’accès spécifié dans l’instruction #using .A path specified in the #using statement.

  • Répertoire actif.The current directory.

  • Répertoire système du .NET Framework.The .NET Framework system directory.

  • Répertoires ajoutés avec l’option du compilateur /ai .Directories added with the /AI compiler option.

  • Répertoires sur la variable d'environnement LIBPATH.Directories on LIBPATH environment variable.

ExemplesExample

Si vous générez un assembly (C) et que vous référencez un assembly (B) qui lui-même fait référence à un autre assembly (A), vous n’aurez pas à référencer explicitement un assembly A, sauf si vous utilisez explicitement l’un des types de A dans C.If you build an assembly (C) and reference an assembly (B) that itself references another assembly (A), you won't have to explicitly reference assembly A unless you explicitly use one of A's types in C.

// using_assembly_A.cpp
// compile with: /clr /LD
public ref class A {};

ExempleExample

// using_assembly_B.cpp
// compile with: /clr /LD
#using "using_assembly_A.dll"
public ref class B {
public:
   void Test(A a) {}
   void Test() {}
};

ExempleExample

Dans l’exemple suivant, il n’y a pas d’erreur de compilateur pour ne pas référencer using_assembly_A. dll, car le programme n’utilise pas les types définis dans using_assembly_A. cpp.In the following sample, there's no compiler error for not referencing using_assembly_A.dll, because the program doesn't use any of the types defined in using_assembly_A.cpp.

// using_assembly_C.cpp
// compile with: /clr
#using "using_assembly_B.dll"
int main() {
   B b;
   b.Test();
}

Voir aussiSee also

Directives de préprocesseurPreprocessor directives