#ifdef in C #

Mi piacerebbe fare il seguito, ma in C # invece di C ++

#ifdef _DEBUG bool bypassCheck=TRUE_OR_FALSE;//i will decide depending on what i am debugging #else bool bypassCheck = false; //NEVER bypass it #endif 

 #if DEBUG bool bypassCheck=TRUE_OR_FALSE;//i will decide depending on what i am debugging #else bool bypassCheck = false; //NEVER bypass it #endif 

Assicurati di avere la casella di controllo per definire DEBUG controllato nelle tue proprietà di costruzione.

#if sarà il tuo nuovo amico, penso.

Se si desidera definire i propri simboli di compilazione personalizzati, è ansible farlo nelle proprietà del progetto (nella scheda Costruisci, “Simboli di compilazione condizionale”).

Ti consiglierei di usare l’ attributo condizionale !

Aggiornamento: 3,5 anni dopo

Puoi usare #if come questo ( esempio copiato da MSDN ):

 // preprocessor_if.cs #define DEBUG #define VC_V7 using System; public class MyClass { static void Main() { #if (DEBUG && !VC_V7) Console.WriteLine("DEBUG is defined"); #elif (!DEBUG && VC_V7) Console.WriteLine("VC_V7 is defined"); #elif (DEBUG && VC_V7) Console.WriteLine("DEBUG and VC_V7 are defined"); #else Console.WriteLine("DEBUG and VC_V7 are not defined"); #endif } } 

Utile solo per escludere parti di metodi.

Se si utilizza #if per escludere qualche metodo dalla compilazione, sarà necessario escludere dalla compilazione tutti i pezzi di codice che chiamano anche quel metodo (a volte è ansible caricare alcune classi in fase di esecuzione e non è ansible trovare il chiamante con “Trova tutti i riferimenti” ). Altrimenti ci saranno errori.

Se usi la compilazione condizionale d’altra parte puoi comunque lasciare tutti i pezzi di codice che chiamano il metodo. Tutti i parametri saranno ancora convalidati dal compilatore. Il metodo non sarà chiamato a runtime . Penso che sia meglio hide il metodo una sola volta e non dover rimuovere anche tutto il codice che lo chiama. Non è consentito utilizzare l’attributo condizionale su metodi che restituiscono valore, solo sui metodi void. Ma non penso che questo sia un grosso limite perché se usi #if con un metodo che restituisce un valore devi hide tutti i pezzi di codice che lo chiamano anche tu.

Ecco un esempio:

     // chiamando Class1.ConditionalMethod () verrà ignorato in fase di runtime 
     // a meno che la costante DEBUG sia definita


     utilizzando System.Diagnostics;
     class Class1 
     {
        [Condizionale ( "DEBUG")]
        public static void ConditionalMethod () {
           Console.WriteLine ("Executed Class1.ConditionalMethod");
        }
     }

Sommario:

#ifdef in C ++ ma con C # / VB #ifdef attributo Conditional. In questo modo si nasconde la definizione del metodo senza dover hide i pezzi di codice che lo chiamano. Il codice chiamante è ancora compilato e convalidato dal compilatore, tuttavia il metodo non viene richiamato in fase di runtime. Potresti voler usare #if per evitare le dipendenze perché con l’attributo Conditional il tuo codice è ancora compilato.

C # ha un preprocessore. Funziona in modo leggermente diverso rispetto a C ++ e C.

Ecco un link MSDN: la sezione su tutte le direttive del preprocessore .