C# Language
Preprocessor richtlijnen

Syntaxis

• #define [symbol] // Definieert een compilatorsymbool.
• #undef [symbol] // Definieert een compilatorsymbool.
• #warning [waarschuwingsbericht] // Genereert een compilerwaarschuwing. Handig met #if.
• #error [error message] // Genereert een compilerfout. Handig met #if.
• #line [regelnummer] (bestandsnaam) // Negeert het regelnummer van de compiler (en optioneel de bronbestandsnaam). Gebruikt met T4-tekstsjablonen .
• #pragma-waarschuwing [uitschakelen | herstellen] [waarschuwingsnummers] // Schakelt compilerwaarschuwingen uit / herstelt.
• #pragma checksum " [bestandsnaam] " " [guid] " " [checksum] " // Valideert de inhoud van een bronbestand.
• #region [regionaam] // Definieert een opvouwbaar codegebied.
• #endregion // Eindigt een coderegionblok.
• #if [voorwaarde] // Voert de onderstaande code uit als de voorwaarde waar is.
• #else // Gebruikt na een #if.
• #elif [voorwaarde] // Gebruikt na een #if.
• #endif // Eindigt een voorwaardelijk blok dat begon met #if.

Opmerkingen

#if !DEBUG && (SOME_SYMBOL || SOME_OTHER_SYMBOL) && RELEASE == true
Console.WriteLine("OK!");
#endif

Voorwaardelijke uitdrukkingen

Wanneer het volgende is gecompileerd, retourneert dit een andere waarde, afhankelijk van welke richtlijnen zijn gedefinieerd.

// Compile with /d:A or /d:B to see the difference
string SomeFunction() 
{
#if A
    return "A";
#elif B
    return "B";
#else
    return "C";
#endif
}

Voorwaardelijke expressies worden meestal gebruikt om extra informatie vast te leggen voor debug-builds.

void SomeFunc()
{
    try
    {
        SomeRiskyMethod();
    }
    catch (ArgumentException ex)
    {
        #if DEBUG
        log.Error("SomeFunc", ex);
        #endif

        HandleException(ex);
    }
}

Compilerwaarschuwingen en fouten genereren

Compiler waarschuwingen kunnen worden gegenereerd met behulp van de #warning richtlijn, en fouten kunnen eveneens worden gegenereerd met behulp van de #error richtlijn.

#if SOME_SYMBOL
#error This is a compiler Error.
#elif SOME_OTHER_SYMBOL
#warning This is a compiler Warning.
#endif

Symbolen definiëren en ongedaan maken

Een compilatorsymbool is een trefwoord dat tijdens het compileren wordt gedefinieerd en waarop kan worden gecontroleerd om voorwaardelijk specifieke secties code uit te voeren.

Er zijn drie manieren om een compilatorsymbool te definiëren. Ze kunnen worden gedefinieerd via code:

#define MYSYMBOL

Ze kunnen worden gedefinieerd in Visual Studio, onder Projecteigenschappen> Bouwen> Voorwaardelijke compilatiesymbolen:

(Merk op dat DEBUG en TRACE hun eigen selectievakjes hebben en niet expliciet hoeven te worden gespecificeerd.)

Of ze kunnen tijdens het compileren worden gedefinieerd met de schakel /define:[name] op de C # compiler, csc.exe .

U kunt ook ongedefinieerde symbolen gebruiken met de #undefine richtlijn.

Het meest voorkomende voorbeeld hiervan is het DEBUG symbool, dat wordt gedefinieerd door Visual Studio wanneer een toepassing wordt gecompileerd in de foutopsporingsmodus (versus de releasemodus).

public void DoBusinessLogic()
{
    try
    {
        AuthenticateUser();
        LoadAccount();
        ProcessAccount();
        FinalizeTransaction();
    }
    catch (Exception ex)
    {
#if DEBUG
        System.Diagnostics.Trace.WriteLine("Unhandled exception!");
        System.Diagnostics.Trace.WriteLine(ex);
        throw;
#else
        LoggingFramework.LogError(ex);
        DisplayFriendlyErrorMessage();
#endif
    }
}

Als in het bovenstaande voorbeeld een fout optreedt in de bedrijfslogica van de toepassing en de toepassing is gecompileerd in de foutopsporingsmodus (en het DEBUG symbool is ingesteld), wordt de fout naar het traceerlogboek geschreven en wordt de uitzondering opnieuw -geworpen voor foutopsporing. Als de toepassing echter is gecompileerd in de vrijgavemodus (en er geen DEBUG symbool is ingesteld), wordt een logboekraamwerk gebruikt om de fout rustig te loggen en wordt een vriendelijk foutbericht weergegeven aan de eindgebruiker.

Regio blokken

Gebruik #region en #endregion om een opvouwbaar #endregion te definiëren.

#region Event Handlers

public void Button_Click(object s, EventArgs e)
{
    // ...
}

public void DropDown_SelectedIndexChanged(object s, EventArgs e)
{
    // ...
}

#endregion

Deze richtlijnen zijn alleen nuttig wanneer een IDE die opvouwbare regio's ondersteunt (zoals Visual Studio ) wordt gebruikt om de code te bewerken.

Andere compilerinstructies

Lijn

#line regelt het regelnummer en de bestandsnaam die door de compiler worden gerapporteerd bij het uitvoeren van waarschuwingen en fouten.

void Test()
{
    #line 42 "Answer"
    #line filename "SomeFile.cs"
    int life; // compiler warning CS0168 in "SomeFile.cs" at Line 42
    #line default
    // compiler warnings reset to default
}

Pragma Checksum

#pragma checksum kan een specifieke checksum worden gespecificeerd voor een gegenereerde programmadatabase (PDB) voor foutopsporing.

#pragma checksum "MyCode.cs" "{00000000-0000-0000-0000-000000000000}" "{0123456789A}"

Het voorwaardelijke kenmerk gebruiken

Het toevoegen van een Conditional kenmerk van de naamruimte System.Diagnostics aan een methode is een schone manier om te bepalen welke methoden in uw builds worden genoemd en welke niet.

#define EXAMPLE_A

using System.Diagnostics;
class Program
{
    static void Main()
    {
        ExampleA(); // This method will be called
        ExampleB(); // This method will not be called
    }

    [Conditional("EXAMPLE_A")]
    static void ExampleA() {...}

    [Conditional("EXAMPLE_B")]
    static void ExampleB() {...}
}

Compiler-waarschuwingen uitschakelen en herstellen

U kunt compilerwaarschuwingen uitschakelen met #pragma warning disable en ze herstellen met #pragma warning restore :

#pragma warning disable CS0168

// Will not generate the "unused variable" compiler warning since it was disabled
var x = 5;

#pragma warning restore CS0168

// Will generate a compiler warning since the warning was just restored
var y = 8;

Door komma's gescheiden waarschuwingsnummers zijn toegestaan:

#pragma warning disable CS0168, CS0219

Het CS voorvoegsel is optioneel en kan zelfs worden gemengd (hoewel dit geen best practice is):

#pragma warning disable 0168, 0219, CS0414

Custom Preprocessors op projectniveau

Het is handig om aangepaste voorwaardelijke voorbewerking op projectniveau in te stellen wanneer sommige acties moeten worden overgeslagen, bijvoorbeeld voor tests.

Ga naar Solution Explorer -> Klik met de rechtermuisknop op het project waarop u de variabele wilt instellen -> Properties -> Build -> zoek in het algemeen het veld Conditional compilation symbols en voer hier uw voorwaardelijke variabele in

Codevoorbeeld waarbij code wordt overgeslagen:

public void Init()
{
    #if !IGNOREREFRESHDB
    // will skip code here
     db.Initialize();
    #endif
}