Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

/clr (Compilación de Common Language Runtime)

Permite a las aplicaciones y a los componentes utilizar las características de Common Language Runtime (CLR).

/clr[:options]

options

Uno o más de los siguientes modificadores, separados por comas.

/clr

Crea metadatos para la aplicación. Los metadatos se pueden usar en otras aplicaciones de CLR, y habilita a la aplicación para poder usar tipos y datos incluidos en los metadatos de otros componentes de CLR.

Para obtener más información, vea

Ensamblados mixtos (nativos y administrados) y

Cómo: Migrar a /clr .

/clr:pure

Genera un Lenguaje intermedio de Microsoft (MSIL) - únicamente el archivo de salida que no tiene ningún código nativo ejecutable. Sin embargo, puede contener tipos nativos compilados para MSIL.

Para obtener más información, vea Código puro y comprobable (C++/CLI).

/clr:safe

Genera un archivo de salida comprobable y solo MSIL (sin código ejecutable nativo). /clr:safe habilita los diagnósticos de comprobación (Herramienta PEVerify (Peverify.exe)).

Para obtener más información, vea Writing Verifiably Type-Safe Code.

/clr:oldSyntax

Habilita la sintaxis de Extensiones administradas para C++, que es la sintaxis original de Visual C++ para la programación CLR. 

La sintaxis de Extensiones administradas para C++ ha quedado desusada. Use /clr:oldSyntax únicamente si conserva una aplicación de Visual C++ que usa Extensiones administradas para C++. Si está desarrollando una nueva aplicación, use la sintaxis actualizada. Para obtener más información, vea Extensiones de componentes para plataformas de tiempo de ejecución.

Si tiene una aplicación Extensiones administradas para C++, puede actualizar el proyecto para usar la nueva sintaxis. Para obtener más información, vea Trasladar y actualizar programas.

/clr:noAssembly

Especifica que no se debe insertar un manifiesto del ensamblado en el archivo de salida. La opción noAssembly está desactivada de forma predeterminada.

La opción noAssembly está desusada. Utilice /LN (Crear un módulo MSIL) en su lugar. Para obtener más información, vea Deprecated Compiler Options.

Un programa administrado que no tiene metadatos de ensamblado en el manifiesto se conoce como un módulo. La opción noAssembly sólo puede utilizarse para generar un módulo. Si compila mediante /c y /clr:noAssembly, especifique la opción /NOASSEMBLY en la fase del vinculador para crear un módulo.

Antes de Visual C++ 2005, /clr:noAssembly implicaba /clr. Sin embargo, /clr ahora también admite /clr:oldSyntax, por lo que debe especificar el formulario /clr cuando especifique /clr:noAssembly. Por ejemplo, /clr:noAssembly /clr crea un módulo mediante la nueva sintaxis de CLR de Visual C++ y /clr:noAssembly,oldSyntax crea un módulo mediante Extensiones administradas para C++.

Antes de Visual C++ 2005, /clr:noAssembly requería /LD. Ahora, /LD va implícito cuando se especifica /clr:noAssembly.

/clr:initialAppDomain

Habilitas a una aplicación Visual C++ para que se ejecute en la versión 1 de CLR. Si utiliza initialAppDomain, puede ver algunos de los problemas que se describen en ERROR: Excepción de AppDomainUnloaded cuando se usan las extensiones administradas para los componentes de Visual C++ el sitio Web de soporte técnico de Microsoft.

Una aplicación que usa ASP.NET no debe usar una aplicación compilada mediante initialAppDomain porque no se admite en la versión 1 de CLR.

/clr:nostdlib

Indica al compilador que omita el directorio \clr predeterminado. El compilador genera errores si se están incluyendo varias versiones de una DLL como System.dll. Esta opción le permite especificar el marco concreto para usar durante la compilación.

Código administrado es el código que puede inspeccionarse y administrarse con CLR. El código administrado tiene acceso a los objetos administrados. Para obtener más información, vea Restricciones de /clr.

Vea Extensiones de componentes para plataformas de tiempo de ejecución para obtener información acerca de cómo desarrollar aplicaciones que definan y usen tipos administrados.

Una aplicación compilada mediante /clr puede o no puede contener datos administrados.

Para habilitar la depuración en una aplicación administrada, vea /ASSEMBLYDEBUG (Agregar DebuggableAttribute).

En la pila de recolección de elementos no utilizados, sólo se crearán instancias de tipos de CLR. Para obtener más información, vea Clases y structs (Extensiones de componentes de C++). Para compilar una función a código nativo, utilice el pragma unmanaged. Para obtener más información, vea managed, unmanaged.

De forma predeterminada, /clr se encuentra desactivado. Cuando /clr está en vigor, /MD también está en vigor. Para obtener más información, vea /MD, /MT, /LD (Utilizar la biblioteca en tiempo de ejecución). /MD asegura que las versiones multithreading vinculadas dinámicamente de las rutinas del motor en tiempo de ejecución están seleccionadas de los archivos de encabezado estándar (.h). El multithreading es necesario para programación administrada porque el recolector de elementos no utilizados de CLR ejecuta los finalizadores en un subproceso auxiliar.

Si compila mediante /c, puede especificar con /CLRIMAGETYPE el tipo de CLR (IJW, seguro o puro) del archivo de salida que se obtiene.

/clr implica /EHa y no se permite ninguna otra opción /EH en /clr. Para obtener más información, vea /EH (Modelo de control de excepciones).

Para obtener información acerca de cómo determinar el tipo de imagen de CLR de un archivo, vea /CLRHEADER.

Todos los módulos pasados a una invocación determinada del vinculador se deben compilar con la misma opción del compilador de la biblioteca en tiempo de ejecución (/MD o /LD).

La opción /ASSEMBLYRESOURCE del vinculador se usa para incrustar un recurso en un ensamblado. Las opciones del vinculador /DELAYSIGN, /KEYCONTAINER y /KEYFILE también permiten personalizar la forma de crear un ensamblado.

Cuando se utiliza /clr, el símbolo _MANAGED se define como 1. Para obtener más información, vea Macros predefinidas.

Las variables globales de un archivo de objeto nativo se inicializan primero (durante DllMain si la aplicación ejecutable es una DLL) y, a continuación, se inicializan las variables globales en la sección administrada (antes de que se ejecute cualquier código administrado). #pragma init_seg solamente afecta al orden de inicialización en las categorías administradas y no administradas.

La compilación mediante /clr:safe es equivalente a la compilación mediante /platform:anycpu en lenguajes como C#.

Imágenes seguras y puras

Una imagen pura usa una versión de CLR de la biblioteca en tiempo de ejecución (CRT) de C. Sin embargo, CRT no es comprobable, por lo que no se puede usar CRT al compilar mediante /clr:safe. Para obtener más información, vea Características de la biblioteca CRT.

Algunos ejemplos de código nativo que no pueden aparecer en una imagen pura incluyen ensamblados alineados, setjmp y longjmp.

Se administra cada punto de entrada de una imagen pura o segura. Cuando realice una compilación con /clr, el punto de entrada es nativo. Para obtener más información, vea __clrcall.

Cuando realice una compilación con /clr:safe, de manera predeterminada, las variables son AppDomain y no pueden depender del proceso. Para /clr:pure, aunque appdomain es la opción predeterminada, puede usar variables de proceso.

Cuando se ejecuta un archivo .exe de 32 bits que se ha compilado mediante /clr o /clr:pure en un sistema operativo de 64 bits, la aplicación se ejecuta bajo WOW64, que habilita a CLR de 32 bits la ejecución en una aplicación de 32 bits en un sistema operativo de 64 bits. De manera predeterminada, un archivo .exe compilado mediante /clr:safe se ejecutará en CLR de 64 bits en un equipo que está ejecutando un sistema operativo de 64 bits. (En un sistema operativo de 32 bits, el mismo archivo .exe se ejecutaría en el CLR de 32 bits.) Sin embargo, una aplicación segura podría cargar un componente de 32 bits. En ese caso, una imagen segura que se ejecute bajo compatibilidad del sistema operativo de 64 bits no podrá cargar la aplicación de 32 bits y se producirá un error (BadFormatException). Para garantizar que una imagen segura se sigue ejecutando cuando carga una imagen de 32 bits en un sistema operativo de 64 bits, debe usar /CLRIMAGETYPE para cambiar los metadatos (.corflags), y marcarla para que se ejecute bajo WOW64. El la línea de comandos siguiente es un ejemplo. (Sustituir su propio símbolo de entrada.)

cl /clr:safe t.cpp /link /clrimagetype:pure /entry:?main@@$$HYMHXZ /subsystem:console

Para obtener información acerca de los cómo obtener un nombre representativo, vea Utilizar una lista para ver nombres representativos. Para obtener más información sobre la programación de 64 bits, vea Programas de configuración para 64 bits (Visual C++).

Para obtener ejemplos, tutoriales y más información, vea:

Metadatos y clases sin nombre

Las clases sin nombre aparecerán en los metadatos denominados como sigue: $UnnamedClass$crc-of-current-file-name$index$, donde es un número index secuencial de las clases sin nombre en la compilación. Por ejemplo, el siguiente código genera una clase sin nombre en los metadatos.

// clr_unnamed_class.cpp
// compile by using: /clr /LD
class {} x;

Use ildasm.exe para ver los metadatos.

Para establecer esta opción del compilador en Visual Studio

  1. En Explorador de soluciones, haga clic con el botón secundario en el nombre del proyecto y, a continuación, haga clic en Propiedades para abrir el cuadro de diálogo Páginas de propiedades del proyecto.

  2. Seleccione la carpeta Propiedades de configuración.

  3. En la página de propiedades General, modifique la propiedad compatible con Common Language Runtime.

    NotaNota

    Cuando /clr está habilitada en el cuadro de diálogo Páginas de propiedades, las propiedades de opciones del compilador que no son compatibles con /clr también se ajustarán según sea necesario. Por ejemplo, si se establece /RTC y, a continuación, se habilita /clr, /RTC se desactivará.

    Asimismo, al depurar una aplicación /clr, la propiedad Tipo de depurador se establece en Mixto o en Sólo administrado. Para obtener más información, vea Configuración del proyecto para una configuración de depuración de C++.

    Vea /NOASSEMBLY (Crear un módulo MSIL) para obtener información sobre cómo crear un módulo.

Para establecer esta opción del compilador mediante programación

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft