C # jeśli / to dyrektywy debugowania vs wydania

We właściwościach rozwiązania mam konfigurację ustawioną na „release” dla mojego jedynego projektu.

Na początku głównej procedury mam ten kod i pokazuje on „Mode = Debug”. Te dwie linie mam też na samej górze:

#define DEBUG 
#define RELEASE

Czy testuję odpowiednią zmienną?

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

Moim celem jest ustawienie różnych wartości domyślnych dla zmiennych opartych na trybie debugowania vs.

DEBUG/ _DEBUGnależy już zdefiniować w VS.

Usuń #define DEBUGw swoim kodzie. Ustaw preprocesory w konfiguracji kompilacji dla tej konkretnej kompilacji.

Powodem, dla którego drukuje „Tryb = Debugowanie”, jest twój, #definea następnie pomija elif.

Właściwy sposób sprawdzenia to:

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

Nie sprawdzaj RELEASE.

Domyślnie Visual Studio definiuje DEBUGĘ, jeśli projekt jest kompilowany w trybie debugowania i nie definiuje go, jeśli jest w trybie zwolnienia. RELEASE nie jest domyślnie zdefiniowane w trybie Release. Użyj czegoś takiego:

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

Jeśli chcesz zrobić coś tylko w trybie zwolnienia:

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

Warto również zauważyć, że można użyć [Conditional("DEBUG")]atrybutu w metodach, które powracają, voidaby były wykonywane tylko wtedy, gdy określony jest określony symbol. Kompilator usunie wszystkie wywołania tych metod, jeśli symbol nie zostanie zdefiniowany:

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

void Test() {
    PrintLog();
}

Wolę to sprawdzić w ten sposób niż szukać #definedyrektyw:

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

Z zastrzeżeniem, że można oczywiście skompilować i wdrożyć coś w trybie debugowania, ale nadal nie ma podłączonego debugera.

Nie jestem wielkim fanem rzeczy #if, szczególnie jeśli rozprowadzasz je wokół swojej bazy kodu, ponieważ spowoduje to problemy z przejściem kompilacji Debug, ale kompilacje Release zakończą się niepowodzeniem, jeśli nie będziesz ostrożny.

Oto co wymyśliłem (zainspirowany #ifdef w 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 '=='

Metoda Debug.Assertma atrybut warunkowy DEBUG. Jeśli nie jest zdefiniowane, połączenie i przypisanie isDebug = true są eliminowane :

Jeśli symbol jest zdefiniowany, połączenie jest uwzględniane; w przeciwnym razie połączenie (w tym ocena parametrów połączenia) zostanie pominięte.

Jeśli DEBUGjest zdefiniowane, isDebugjest ustawione na true(i przekazywane do Debug.Assert, co w tym przypadku nic nie robi).

Jeśli próbujesz użyć zmiennej zdefiniowanej dla typu kompilacji, powinieneś usunąć dwie linie ...

#define DEBUG  
#define RELEASE 

... spowoduje to #if (DEBUG) będzie zawsze prawdziwe.

Nie ma też domyślnego symbolu kompilacji warunkowej dla WYDANIA . Jeśli chcesz zdefiniować jedno przejście do właściwości projektu, kliknij kartę Kompiluj , a następnie dodaj UWOLNIENIE do pola tekstowego Symbole kompilacji warunkowej pod nagłówkiem Ogólne .

Inną opcją byłoby zrobienie tego ...

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

Usuń definicje u góry

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

Nieznacznie zmodyfikowana (zaryzykowana?) Wersja odpowiedzi Toda Thomsona jako funkcja statyczna, a nie osobna klasa (chciałem móc ją wywoływać w powiązaniu widoku WebForm z klasy viewutils, którą już załączyłem).

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

    WellAreWe(ref debugging);

    return debugging;
}

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

Należy zdefiniować stałą DEBUG we właściwościach kompilacji projektu. Umożliwi to #if DEBUG. Nie widzę wstępnie zdefiniowanej stałej RELEASE, więc może to sugerować, że wszystko, co nie jest w bloku DEBUG, jest trybem RELEASE.

NameSpace

using System.Resources;
using System.Diagnostics;

metoda

   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;
    }

Wskazówka, która może zaoszczędzić dużo czasu - nie zapomnij o tym, nawet jeśli wybierzesz debug w konfiguracji kompilacji (w menu vs2012 / 13 jest to w BUILD => MENEDŻER KONFIGURACJI) - to nie wystarczy.

Musisz zwrócić uwagę na PUBLIKAC Configurationjako taki:

Ponieważ celem tych dyrektyw KOMPILERA jest poinformowanie kompilatora, aby NIE zawierał kodu, kodu debugowania, kodu beta, a może kodu, który jest potrzebny wszystkim użytkownikom końcowym, z wyjątkiem tych, którzy mówią działowi reklamy, tj. #Define AdDept, który chcesz być w stanie je uwzględnić lub usunąć w zależności od potrzeb. Bez konieczności zmiany kodu źródłowego, jeśli na przykład nie-AdDept łączy się z AdDept. Następnie wszystko, co należy zrobić, to dołączyć dyrektywę #AdDept do strony właściwości opcji kompilatora istniejącej wersji programu i wykonać kompilację i wa la! kod scalonego programu odżywa!

Możesz także użyć deklaratywnego dla nowego procesu, który nie jest gotowy na czas pierwszorzędny lub który nie może być aktywny w kodzie, dopóki nie nadejdzie czas na jego zwolnienie.

W każdym razie tak to robię.

Zacząłem myśleć o lepszym sposobie. Przyszło mi do głowy, że bloki #if są skutecznie komentarzami w innych konfiguracjach (przy założeniu DEBUGlub RELEASE; ale prawdziwe z dowolnym symbolem)

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");
        }

Usuń definicje i sprawdź, czy warunek jest w trybie debugowania. Nie musisz sprawdzać, czy dyrektywa jest w trybie zwolnienia.

Coś takiego:

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