#ifdef in C #

116

Vorrei fare quanto segue ma in C # invece che in 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

c#

Controlla anche questa eccellente risposta , mostra come puoi aggiungere simboli di debug in base alle condizioni tramite il file di progetto (.csproj).

— Matt

162

#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 selezionata nelle proprietà di build.

— heavyd
fonte

51

Ti consiglierei di usare l' attributo condizionale !

Aggiornamento: 3,5 anni dopo

Puoi usare in #ifquesto modo ( 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 utilizzi #ifper escludere un metodo dalla compilazione, dovrai escludere dalla compilazione tutte le parti di codice che chiamano anche quel metodo (a volte potresti caricare alcune classi in fase di esecuzione e non riesci a trovare il chiamante con "Trova tutti i riferimenti"). Altrimenti ci saranno errori.

Se usi la compilazione condizionale, d'altra parte, puoi ancora lasciare tutte le parti di codice che chiamano il metodo. Tutti i parametri verranno comunque convalidati dal compilatore. Il metodo semplicemente non verrà chiamato in fase di esecuzione . Penso che sia molto meglio nascondere il metodo solo una volta e non dover rimuovere anche tutto il codice che lo chiama. Non è consentito utilizzare l'attributo condizionale su metodi che restituiscono valore - solo su metodi void. Ma non credo che questo sia un grosso limite perché se usi #ifun metodo che restituisce un valore devi nascondere anche tutti i pezzi di codice che lo chiamano.

Ecco un esempio:

    // la chiamata a Class1.ConditionalMethod () verrà ignorata in fase di esecuzione 
    // a meno che non sia definita la costante DEBUG


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

Sommario:

Lo userei #ifdefin C ++ ma con C # / VB userei l'attributo condizionale. In questo modo nascondi la definizione del metodo senza dover nascondere i pezzi di codice che lo chiamano. Il codice chiamante è ancora compilato e convalidato dal compilatore, tuttavia il metodo non viene chiamato in fase di esecuzione. Potresti usarlo #ifper evitare dipendenze perché con l'attributo Conditional il tuo codice è ancora compilato.

— Pavel Nikolov
fonte

1

+1 Questo è davvero carino, ma ha dei limiti, come quando si tenta di restituire un valore da un metodo condizionale (a quanto ho capito). Un esempio in linea aiuterebbe, credo.

— Hamish Grubijan

1

Inoltre non impedisce la compilazione del codice, semplicemente non consente quel codice. La distinzione è importante quando si desidera rimuovere le dipendenze e simili.

— Lee Louviere

1

C # ha un preprocessore. Funziona in modo leggermente diverso da quello di C ++ e C.

Ecco i collegamenti MSDN, la sezione su tutte le direttive del preprocessore .

— Karl T.
fonte

11

È un punto minore, ma C # NON ha un preprocessore. # le direttive vengono elaborate dal compilatore principale come se ci fosse un preprocessore. Vedere qui: msdn.microsoft.com/en-us/library/ed8yd1ha.aspx Il risultato principale di questa distinzione è che le macro in stile c / c ++ non funzionano.

— Simon P Stevens