C # if / then-Anweisungen für Debug vs Release

In den Lösungseigenschaften ist die Konfiguration für mein einziges Projekt auf "Freigeben" festgelegt.

Zu Beginn der Hauptroutine habe ich diesen Code und er zeigt "Mode = Debug". Ich habe auch diese beiden Zeilen ganz oben:

#define DEBUG 
#define RELEASE

Teste ich die richtige Variable?

#if (DEBUG)
            Console.WriteLine("Mode=Debug"); 
#elif (RELEASE)
            Console.WriteLine("Mode=Release"); 
#endif

Mein Ziel ist es, verschiedene Standardeinstellungen für Variablen festzulegen, die auf dem Debug- und dem Release-Modus basieren.

DEBUG/ _DEBUGsollte bereits in VS definiert sein.

Entfernen Sie das #define DEBUGin Ihrem Code. Legen Sie Präprozessoren in der Build-Konfiguration für diesen bestimmten Build fest.

Der Grund, warum "Mode = Debug" gedruckt wird, liegt an Ihrem #defineund überspringt dann das elif.

Der richtige Weg zu überprüfen ist:

#if DEBUG
    Console.WriteLine("Mode=Debug"); 
#else
    Console.WriteLine("Mode=Release"); 
#endif

Nicht nachsehen RELEASE.

Standardmäßig definiert Visual Studio DEBUG, wenn das Projekt im Debug-Modus kompiliert wird, und definiert es nicht, wenn es sich im Release-Modus befindet. RELEASE ist standardmäßig nicht im Release-Modus definiert. Verwenden Sie so etwas:

#if DEBUG
  // debug stuff goes here
#else
  // release stuff goes here
#endif

Wenn Sie etwas nur im Release-Modus tun möchten:

#if !DEBUG
  // release...
#endif

Es ist auch erwähnenswert, dass Sie [Conditional("DEBUG")]Attribute für Methoden verwenden können, die zurückkehren void, um sie nur auszuführen, wenn ein bestimmtes Symbol definiert ist. Der Compiler würde alle Aufrufe dieser Methoden entfernen, wenn das Symbol nicht definiert ist:

[Conditional("DEBUG")]
void PrintLog() {
    Console.WriteLine("Debug info");
}

void Test() {
    PrintLog();
}

Ich ziehe es vor, es so zu überprüfen, anstatt nach #defineAnweisungen zu suchen :

if (System.Diagnostics.Debugger.IsAttached)
{
   //...
}
else
{
   //...
}

Mit der Einschränkung, dass Sie natürlich etwas im Debug-Modus kompilieren und bereitstellen können, aber den Debugger immer noch nicht angehängt haben.

Ich bin kein großer Fan des # if-Materials, besonders wenn Sie es über Ihre gesamte Codebasis verteilen, da es Ihnen Probleme gibt, wenn Debug-Builds erfolgreich sind, Release-Builds jedoch fehlschlagen, wenn Sie nicht vorsichtig sind.

Folgendes habe ich mir ausgedacht (inspiriert von #ifdef in C # ):

public interface IDebuggingService
{
    bool RunningInDebugMode();
}

public class DebuggingService : IDebuggingService
{
    private bool debugging;

    public bool RunningInDebugMode()
    {
        //#if DEBUG
        //return true;
        //#else
        //return false;
        //#endif
        WellAreWe();
        return debugging;
    }

    [Conditional("DEBUG")]
    private void WellAreWe()
    {
        debugging = true;
    }
}

bool isDebug = false;
Debug.Assert(isDebug = true); // '=', not '=='

Die Methode Debug.Asserthat ein bedingtes Attribut DEBUG. Wenn es nicht definiert ist, wird der Anruf und die Zuordnung isDebug = true werden eliminiert :

Wenn das Symbol definiert ist, ist der Anruf enthalten. Andernfalls wird der Anruf (einschließlich der Auswertung der Parameter des Anrufs) weggelassen.

Wenn DEBUGdefiniert ist, isDebugwird auf gesetzt true(und an übergeben Debug.Assert, was in diesem Fall nichts bewirkt).

Wenn Sie versuchen, die für den Build-Typ definierte Variable zu verwenden, sollten Sie die beiden Zeilen entfernen ...

#define DEBUG  
#define RELEASE 

... dies führt dazu, dass das #if (DEBUG) immer wahr ist.

Außerdem gibt es kein Standard-Symbol für die bedingte Kompilierung für RELEASE . Wenn Sie einen definieren möchten, gehen Sie zu den Projekteigenschaften, klicken Sie auf die Registerkarte Erstellen und fügen Sie dann RELEASE zum Textfeld Bedingte Kompilierungssymbole unter Allgemein hinzu Überschrift .

Die andere Möglichkeit wäre, dies zu tun ...

#if DEBUG
    Console.WriteLine("Debug");
#else
    Console.WriteLine("Release");
#endif

Entfernen Sie Ihre Definitionen oben

#if DEBUG
        Console.WriteLine("Mode=Debug"); 
#else
        Console.WriteLine("Mode=Release"); 
#endif

Leicht modifizierte (bastardisierte?) Version der Antwort von Tod Thomson als statische Funktion und nicht als separate Klasse (ich wollte sie in einer WebForm-Ansichtsbindung aus einer Viewutils-Klasse aufrufen können, die ich bereits aufgenommen hatte).

public static bool isDebugging() {
    bool debugging = false;

    WellAreWe(ref debugging);

    return debugging;
}

[Conditional("DEBUG")]
private static void WellAreWe(ref bool debugging)
{
    debugging = true;
}

Stellen Sie sicher, dass Sie die DEBUG-Konstante in den Project Build-Eigenschaften definieren. Dies aktiviert die #if DEBUG. Ich sehe keine vordefinierte RELEASE-Konstante, was bedeuten könnte, dass alles, was sich nicht in einem DEBUG-Block befindet, im RELEASE-Modus ist.

NameSpace

using System.Resources;
using System.Diagnostics;

Methode

   private static bool IsDebug()
    {
        object[] customAttributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(DebuggableAttribute), false);
        if ((customAttributes != null) && (customAttributes.Length == 1))
        {
            DebuggableAttribute attribute = customAttributes[0] as DebuggableAttribute;
            return (attribute.IsJITOptimizerDisabled && attribute.IsJITTrackingEnabled);
        }
        return false;
    }

Ein Tipp, der Ihnen viel Zeit sparen kann - vergessen Sie das nicht, auch wenn Sie möchten debug unter Build-Konfiguration (im Menü vs2012 / 13 unter BUILD => CONFIGURATION MANAGER).

Sie müssen auf das PUBLISH Configurationals solches achten :

Da der Zweck dieser COMPILER-Anweisungen darin besteht, den Compiler anzuweisen, KEINEN Code, Debug-Code, Beta-Code oder möglicherweise Code einzuschließen, der von allen Endbenutzern benötigt wird, mit Ausnahme derjenigen der Werbeabteilung, dh #Define AdDept, die Sie möchten Sie können sie je nach Bedarf einschließen oder entfernen. Ohne Ihren Quellcode ändern zu müssen, wenn beispielsweise ein Nicht-AdDept in das AdDept übergeht. Dann müssen Sie nur noch die Direktive #AdDept in die Eigenschaftenseite der Compileroptionen einer vorhandenen Version des Programms aufnehmen und eine Kompilierung durchführen und wa la! Der Code des zusammengeführten Programms wird lebendig!.

Möglicherweise möchten Sie auch ein Deklarativ für einen neuen Prozess verwenden, der nicht zur Hauptsendezeit bereit ist oder der erst dann im Code aktiv sein kann, wenn es Zeit ist, ihn freizugeben.

Jedenfalls mache ich das so.

Ich musste über einen besseren Weg nachdenken. Mir wurde klar, dass # if-Blöcke in anderen Konfigurationen effektiv Kommentare sind (vorausgesetzt DEBUGoder RELEASE; aber wahr mit jedem Symbol)

public class Mytest
    {
        public DateTime DateAndTimeOfTransaction;
    }

    public void ProcessCommand(Mytest Command)
        {
            CheckMyCommandPreconditions(Command);
            // do more stuff with Command...
        }

        [Conditional("DEBUG")]
        private static void CheckMyCommandPreconditions(Mytest Command)
        {
            if (Command.DateAndTimeOfTransaction > DateTime.Now)
                throw new InvalidOperationException("DateTime expected to be in the past");
        }

Entfernen Sie die Definitionen und prüfen Sie, ob sich die Bedingung im Debug-Modus befindet. Sie müssen nicht überprüfen, ob sich die Direktive im Freigabemodus befindet.

Etwas wie das:

#if DEBUG
     Console.WriteLine("Mode=Debug"); 
#else
    Console.WriteLine("Mode=Release"); 
#endif