Directiva #using (C++/CLI)

  • Artículo

Importa metadatos en un programa compilado con /clr.

Sintaxis

#usingfile [as_friend]

Parámetros

file
Un archivo de Lenguaje intermedio de Microsoft (MSIL) .dll, .exe, .netmodule o .obj. Por ejemplo,

#using <MyComponent.dll>

as_friend
Especifica que todos los tipos en file son accesibles. Para obtener más información, vea Ensamblados de confianza (C++).

Comentarios

file puede ser un archivo de Lenguaje intermedio de Microsoft (MSIL) que importe para sus datos administrados y construcciones administradas. Si una DLL contiene un manifiesto del ensamblado, se importan todos los archivos DLL a los que se hace referencia en el manifiesto. El ensamblado que va a compilar mostrará una lista de file en los metadatos como referencia de ensamblado.

Quizás file no contenga un ensamblado (file es un módulo) y no tiene pensado usar la información de tipo del módulo en la aplicación actual (ensamblado). Puede indicar que el módulo forma parte del ensamblado mediante /ASSEMBLYMODULE. Los tipos del módulo estarán disponibles entonces para cualquier aplicación que hiciera referencia al ensamblado.

Una alternativa al uso de #using es la opción /FU del compilador.

Los ensamblados .exe pasados a #using deben compilarse mediante uno de los compiladores de Visual Studio de .NET (Visual Basic o Visual C#, por ejemplo). Si se intenta importar metadatos de un ensamblado .exe compilado con /clr, se producirá una excepción de carga del archivo.

Nota:

Un componente al que se hace referencia con #using puede ejecutarse con una versión diferente del archivo importado en tiempo de compilación, lo que hace que una aplicación cliente proporcione resultados inesperados.

Para que el compilador reconozca un tipo en un ensamblado (no un módulo), se debe forzar la resolución del tipo. Puede forzarla, por ejemplo, definiendo una instancia del tipo. Hay otras formas de resolver nombres de tipo en un ensamblado para el compilador. Por ejemplo, si se hereda de un tipo en un ensamblado, el nombre del tipo pasa a ser conocido para el compilador.

Cuando se importan metadatos compilados a partir de código fuente que usó __declspec(thread), la semántica de subproceso no se conserva en los metadatos. Por ejemplo, una variable declarada con __declspec(thread), compilada en un programa compilado para Common Language Runtime de .NET Framework y luego importado a través de #using, no tendrá semántica de __declspec(thread) en la variable.

Todos los tipos importados (tanto administrados como nativos) en un archivo al que hace referencia #using están disponibles, pero el compilador trata los tipos nativos como declaraciones, no como definiciones.

Se hace referencia automáticamente a mscorlib.dll cuando se compila con /clr.

La variable de entorno LIBPATH especifica los directorios que hay que buscar cuando el compilador resuelva los nombres de archivo pasados a #using.

El compilador busca las referencias en la ruta de acceso siguiente:

  • Una ruta de acceso especificada en la instrucción #using.

  • El directorio actual.

  • El directorio del sistema de .NET Framework.

  • Directorios agregados con la opción /AI del compilador.

  • Directorios de la variable de entorno LIBPATH.

Ejemplos

Puede compilar un ensamblado que haga referencia a un segundo ensamblado que a su vez haga referencia a un tercer ensamblado. Solo tiene que hacer referencia de forma explícita al tercer ensamblado desde el primero si usa explícitamente uno de sus tipos.

Archivo de origen using_assembly_A.cpp:

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

Archivo de origen using_assembly_B.cpp:

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

En el ejemplo siguiente, el compilador no informa de un error sobre cómo hacer referencia a using_assembly_A.dll, porque el programa no usa ninguno de los tipos definidos en using_assembly_A.cpp.

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

Consulte también

Directivas de preprocesador