C# Language
Directives du préprocesseur

Syntaxe

• #define [symbole] // Définit un symbole de compilation.
• #undef [symbole] // Annule un symbole du compilateur.
• #warning [message d'avertissement] // Génère un avertissement de compilation. Utile avec #if.
• # erreur [message d'erreur] // Génère une erreur de compilation. Utile avec #if.
• #line [numéro de ligne] (nom du fichier) // Remplace le numéro de ligne du compilateur (et éventuellement le nom du fichier source). Utilisé avec les modèles de texte T4 .
• #pragma warning [disable | restore] [numéros d'avertissement] // Désactive / restaure les avertissements du compilateur.
• #pragma checksum " [nomfichier] " " [guid] " " [somme de contrôle] " // Valide le contenu du fichier source.
• #region [nom de la région] // Définit une région de code réductible.
• #endregion // Termine un bloc de région de code.
• #if [condition] // Exécute le code ci-dessous si la condition est vraie.
• #else // Utilisé après un #if.
• #elif [condition] // Utilisé après un #if.
• #endif // Termine un bloc conditionnel démarré avec #if.

Remarques

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

Expressions conditionnelles

Lorsque ce qui suit est compilé, il renverra une valeur différente selon les directives définies.

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

Les expressions conditionnelles sont généralement utilisées pour enregistrer des informations supplémentaires pour les versions de débogage.

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

        HandleException(ex);
    }
}

Génération des avertissements et des erreurs du compilateur

Les avertissements du compilateur peuvent être générés à l'aide de la directive #warning , et des erreurs peuvent également être générées à l'aide de la directive #error .

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

Définition et suppression de symboles

Un symbole de compilateur est un mot clé défini au moment de la compilation, qui peut être vérifié pour exécuter certaines sections de code de manière conditionnelle.

Il existe trois façons de définir un symbole de compilateur. Ils peuvent être définis via le code:

#define MYSYMBOL

Ils peuvent être définis dans Visual Studio, sous Propriétés du projet> Créer> Symboles de compilation conditionnels:

(Notez que DEBUG et TRACE ont leurs propres cases à cocher et qu’il n’est pas nécessaire de les spécifier explicitement.)

Ou ils peuvent être définis à la compilation en utilisant le commutateur /define:[name] sur le compilateur C #, csc.exe .

Vous pouvez également #undefine symboles non définis à l'aide de la directive #undefine .

L'exemple le plus courant est le symbole DEBUG , défini par Visual Studio lorsqu'une application est compilée en mode Debug (en mode Release).

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

Dans l'exemple ci-dessus, lorsqu'une erreur survient dans la logique métier de l'application, si l'application est compilée en mode débogage (et que le symbole DEBUG est défini), l'erreur sera consignée dans le journal de suivi et l'exception sera supprimée. -pour le débogage. Toutefois, si l'application est compilée en mode Release (et qu'aucun symbole DEBUG n'est défini), une structure de journalisation est utilisée pour consigner discrètement l'erreur et un message d'erreur convivial s'affiche pour l'utilisateur final.

Blocs de région

Utilisez #region et #endregion pour définir une région de code #endregion .

#region Event Handlers

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

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

#endregion

Ces directives ne sont utiles que lorsqu'un IDE prenant en charge des régions réductibles (telles que Visual Studio ) est utilisé pour modifier le code.

Autres instructions du compilateur

Ligne

#line contrôle le numéro de ligne et le nom de fichier signalés par le compilateur lors de la sortie des avertissements et des erreurs.

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
}

Somme de contrôle Pragma

#pragma checksum permet de spécifier une somme de contrôle spécifique pour une base de données de programme (PDB) générée pour le débogage.

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

Utilisation de l'attribut conditionnel

L'ajout d'un attribut Conditional de l'espace de noms System.Diagnostics à une méthode est un moyen efficace de contrôler les méthodes appelées dans vos builds et celles qui ne le sont pas.

#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() {...}
}

Désactiver et restaurer les avertissements du compilateur

Vous pouvez désactiver les avertissements du compilateur en utilisant l'avertissement #pragma warning disable et les restaurer à l'aide de la #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;

Les numéros d'avertissement séparés par des virgules sont autorisés:

#pragma warning disable CS0168, CS0219

Le préfixe CS est facultatif et peut même être mélangé (bien que ce ne soit pas une bonne pratique):

#pragma warning disable 0168, 0219, CS0414

Préprocesseurs personnalisés au niveau du projet

Il est pratique de définir un prétraitement conditionnel personnalisé au niveau du projet lorsque certaines actions doivent être ignorées, disons pour les tests.

Accédez à l' Solution Explorer -> Cliquez avec le bouton droit de la souris sur le projet que vous souhaitez définir comme variable -> Properties -> Build -> En général Rechercher champ Conditional compilation symbols et entrez votre variable conditionnelle ici

Exemple de code qui ignorera du code:

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