C Directiva # para indicar de 32 bits o 64 bits construyen

Question

¿Hay algún tipo de C# directiva para utilizar cuando se utiliza una máquina de desarrollo (32 bits o 64 bits) que dice algo en el sentido de:

 
if (32-bit Vista) 
    // set a property to true 
else if (64-bit Vista) 
    // set a property to false 

pero quiero hacer esto en Visual Studio ya que tengo una aplicación en la que estoy trabajando que necesita probarse en las versiones de 32/64 bit de Vista.

¿Es esto posible?

Answer 1

¿Se puede hacer en tiempo de ejecución?

if (IntPtr.Size == 4) 
    // 32 bit 
else if (IntPtr.Size == 8) 
    // 64 bit 

Answer 2

No hay nada incorporado que haga esto por usted. Siempre puede #define su propio símbolo y usarlo para la compilación condicional si lo desea.

Answer 3

Puede utilizar una directiva #if y establecer el valor como un modificador de compilador (o en la configuración del proyecto):

#if VISTA64 
    ... 
#else 
    ... 
#endif 

y compilar con:

csc /d:VISTA64 file1.cs 

al compilar una versión de 64 bits .

Answer 4

Hay dos condiciones a tener en cuenta con 64 bits. Primero está el OS de 64 bits, y el segundo es la aplicación que se ejecuta en 64 bits. Si sólo estás preocupado por la propia aplicación se puede utilizar lo siguiente:

if(IntPtr.Size == 8) 
    // Do 64-bit stuff 
else 
    // Do 32-bit 

En tiempo de ejecución, el compilador JIT puede optimizar la distancia del falso condicional porque la propiedad IntPtr.Size es constante.

Por cierto, para comprobar si el sistema operativo es de 64 bits se utiliza la siguiente

if(Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432") != null) 
    // OS is 64-bit; 
else 
    // OS is 32-bit 

Answer 5

Abra la Configuration Manager del Build. Desde allí, debe poder configurar Active solution platform y crear una configuración específica para x64, x86 o cualquier CPU. Desde allí, puede tener un código que compila de forma condicional en función de la configuración actual.

Tenga en cuenta que esta suele ser una muy mala idea. Los programas .Net se distribuyen normalmente como IL en lugar de código nativo. Esta IL luego es compilada por el compilador JIT en cada máquina local la primera vez que el usuario intenta ejecutarla. Al dejar el valor predeterminado "Cualquier CPU" seleccionado, permite que el compilador JIT tome esa determinación para cada máquina individual.

La excepción principal para esto es cuando tiene una dependencia en una biblioteca de 32 bits. En ese caso, no desea que el compilador JIT compile alguna vez para x64, ya que podría romper su interoperabilidad con la biblioteca.

Answer 6

No estoy seguro de si esto es lo que está buscando, pero compruebo el IntPtr.Size para detectar el tiempo de ejecución de 32 bits frente a 64 bits. Tenga en cuenta que este le dice que el entorno de ejecución, puede ser que funcione en WOW64

if (IntPtr.Size == 4) 
{ 
    //32 bit 
} 
else if (IntPtr.Size == 8) 
{ 
    //64 bit 
} 
else 
{ 
    //the future 
} 

Answer 7

Lo que yo uso en mi código C# es IntPtr.Tamaño, que es igual a 4 en 32 bits y 8 sobre 64 bits:

string framework = (IntPtr.Size == 8) ? "Framework64" : "Framework"; 

Answer 8

Puede utilizar predefinidas macros para establecer las propiedades de compilación

#if (_WIN64) 
    const bool IS_64 = true; 
#else 
    const bool IS_64 = false; 
#endif 

Answer 9

sé que este es un viejo tema, pero recientemente he tenido para obtener el mismo resultado (es decir, determinar en tiempo de compilación, no tiempo de ejecución)

Creé nuevas configuraciones de compilación (depuración x86, versión x86, depuración x64, versión x64) y configuré BUILD64 o BUILD32 en los "Símbolos de compilación condicionales" cuadro en las propiedades de la aplicación para cada configuración.

Cuando tuve que hacer algo diferente entre compilaciones (como cambiar la firma en algunos métodos exportados x86 de un archivo .dll), utilicé las directivas de compilación estándar para lograr lo que necesitaba. por ejemplo:

#if BUILD64 
// 64 Bit version 
// do stuff here 
#endif 

#if BUILD32 
// 32 Bit version 
// do different stuff here 
#endif