Introduction

Tout d’abord, un mot clé (ou keyword an anglais) est un mot réservé qui a une signification particulière pour le compilateur. Les mots clés ne pourront donc pas être utilisés pour identifier les variables, classes ou encore les fonctions.

Au cours de cet article, l’ensemble des mots clés de C# vous seront présentés. Vous verrez aussi comment les utiliser pour identifier des variables, méthodes voir classes contrairement à ce qui a été dit précédemment.

Des mots pas si réservés que ça…

Bien que déconseillé, il vous est tout à fait possible d’utiliser les mots clés pour identifier les variables, classes et autres.

Première technique – sensibilité à la casse

C# étant sensible à la casse, vous pouvez donc utiliser un mot clé en modifiant sa casse d’origine :

void While()
{
    int iF = 0;
}

Seconde technique – préfixe @

La seconde technique permet d’utiliser un mot clé en le préfixant de @ :

void @while()
{
    int @if = 0;
}

Liste des mots clés

Voici la liste des mots clés qui seront détaillés par la suite :

  • abstract
  • as
  • base
  • bool
  • break
  • byte
  • case
  • catch
  • char
  • checked
  • class
  • const
  • continue
  • decimal
  • default
  • delegate
  • do
  • double
  • else
  • enum
  • event
  • explicit
  • extern
  • false
  • finally
  • fixed
  • float
  • for
  • foreach
  • goto
  • if
  • implicit
  • in
  • int
  • interface
  • internal
  • is
  • lock
  • long
  • namespace
  • new
  • null
  • object
  • operator
  • out
  • override
  • params
  • private
  • protected
  • public
  • readonly
  • ref
  • return
  • sbyte
  • sealed
  • short
  • sizeof
  • stackalloc
  • static
  • string
  • struct
  • switch
  • this
  • throw
  • true
  • try
  • typeof
  • uint
  • ulong
  • unchecked
  • unsafe
  • ushort
  • using
  • virtual
  • volatile
  • void
  • while

Description des mots clés

abstract

Le mot clé abstract est utilisé avec les classes, méthodes, propriétés, indexeurs et évènements. En utilisant abstract dans la déclaration d’une classe, cela signifiera que cette classe est une classe de base qui ne pourra pas être instanciée directement. Pour ce qui est des membres marqués comme abstraits ou contenus dans une classe abstraite, ils devront être implémentés dans la classe qui dérive de la classe abstraite.

abstract public class Animal
{
    abstract public string Cri();
}

public class Chien : Animal
{
    public override string Cri()
    {
        return "Waf !!!";
    }
}

static void Main()
{
    // Animal monAnimal = new Animal(); -> Impossible
    Chien monChient = new Chien();
}

as

Le mot clé as permet de vérifier qu’un objet est bien d’un certain de type. Si la condition est vérifiée un casting implicite est effectué pour récupérer l’objet sous le bon type, dans le cas contraire, null sera renvoyé.

abstract public class Animal
{
    abstract public string Cri();
}

public class Chien : Animal
{
    public override string Cri()
    {
        return "Waf !!!";
    }
}
public class Chat : Animal
{
    public override string Cri()
    {
        return "Miaouuu !!!";
    }
}

static void Main()
{
    Object[] mesAnimaux = { new Chien(), new Chat() };

    foreach (Object AnimalCourant in mesAnimaux)
    {
        Chien monChien = AnimalCourant as Chien;
        Chat monchat = AnimalCourant as Chat;

        if (monChien != null)
            Console.WriteLine("Voici le cri du chien : {0}", monChien.Cri());
        else if (monchat != null)
            Console.WriteLine("Voici le cri du chat : {0}", monchat.Cri());
        else
            Console.WriteLine("Animal inconnu !");
    }
}

base

Le mot clé base permet d’accéder depuis une classe dérivée à la classe de base.

public class Chien : Animal
{
    public override string Cri()
    {
        return "Waf !!!";
    }
}

public class Labrador : Chien
{
    public string CriLabrador()
    {
        return base.Cri();
    }
}

bool

Le mot clé bool est un alias de la structure System.Boolean. Vous pourrez donc aussi bien utiliser bool que Boolean pour déclarer une variable booléenne.

bool monBoolAlias = true;
Boolean monBooleanStructure = monBoolAlias;

break

Le mot clé break permet de sortir d’une boucle ou d’un switch.

for (int i = 0; i < 5; i++)
{
    if (i == 2)
    {
        Console.WriteLine("On peut quitter la boucle !");
        break;
    }
}
Console.WriteLine("Voulez-vous quitter ? [O pour oui - N pour non]");
string ret = Console.ReadLine();

switch (ret.ToUpper()[0])
{
    case 'O': 
        Console.WriteLine("Au revoir");
        break;
    case 'N':
        Console.WriteLine("On continue alors...");
        break;
    default:
        Console.WriteLine("Commande inconnue !");
        break;
}

byte

Le mot clé byte est un alias de la structure System.Byte. Vous pourrez y stocker une valeur entière non signée codée sur 8 bits (de 0 à 255).

byte monByteAlias = 5;
Byte = monByteStructure = monByteAlias;

case

Le mot clé case représente un des aiguillages de l’instruction switch.

Console.WriteLine("Voulez-vous quitter ? [O pour oui - N pour non]");
string ret = Console.ReadLine();

switch (ret.ToUpper()[0])
{
    case 'O': 
        Console.WriteLine("Au revoir");
        break;
    case 'N':
        Console.WriteLine("On continue alors...");
        break;
    default:
        Console.WriteLine("Commande inconnue !");
        break;
}

catch

Le mot clé catch permet de traiter une exception qui a été levée dans le bloc try précédent. Si les instructions dans le bloc try peuvent lever plusieurs exceptions différentes, il est possible de les intercepter en faisant suivre le bloc try par plusieurs bloc catch.

try
{
    int i = 0;
    int j = 5;

    int ret = j / i;
}
catch (DivideByZeroException exc) 
{
    Console.WriteLine("Voici le message de l'erreur : {0}", exc.Message);
}

Remarque : Si vous désirez intercepter n’importe quelle exception dans un unique bloc catch, il vous suffit d’intercepter l’exception Exception qui est la classe de base de toute exception.

char

Le mot clé char est un alias de la structure System.Char. Il vous permet de déclarer un caractère Unicode.

char monCharAlias = 'A';
Char monCharStructure = monCharAlias;

checked

Par défaut, C# ne signale aucune erreur en cas de dépassement de capacité sur des entiers. La valeur résultante sera donc erronée dans un tel cas. Le mot clé checked permet de générer une exception en cas de dépassement de capacité lors d’opérations arithmétiques, conversions ou encore division par 0.

int i = 0;
int j = 1;

// i = -2147483648
i = Int32.MaxValue + j;

try
{
    int k = 0;
    int l = 1;
    k = checked(Int32.MaxValue + l);
}
catch (Exception)
{
    Console.WriteLine("Dépassement de capacité !");
}

class

Le mot clé class, comme son l’indique, permet de déclarer une classe.

class maClasse
{ }

const

Le mot clé const permet de déclarer une variable en tant que constante. L’initialisation devra se faire en même temps que la déclaration, car il ne sera plus possible de modifier la valeur de la variable par après.

const int maConstante = 2007;

continue

Le mot clé continue va de pair avec break. continue permet de passer à l’itération suivante dans une boucle contrairement à break qui permet de sortir de la boucle.

for (int i = 0; i < 5; i++)
{
    if (i == 1)
    { 
        // On passe directement à l'itération suivante sans afficher le message
        continue;
    }

    Console.WriteLine("Numéro de l'itération : {0}", i);
}

decimal

Le mot clé decimal est un alias de la structure System.Decimal. Ce type permet d’avoir une plus grande précision que le type float. On peut y stocker une valeur de type flottante codée sur 128 bits (environ 8*10^28).

decimal monDecimalAlias = 9.1m;
Decimal monDecimalStructure = monDecimalAlias;

default

Le mot clé default a deux significations :

Dans un bloc switch, default représente le bloc par défaut lorsqu’aucun aiguillage ne correspond.

switch (3)
{
    case 1: Console.WriteLine("Valeur 1"); break;
    case 2: Console.WriteLine("Valeur 2"); break;
    default: Console.WriteLine("Valeur par defaut"); break;
}

Sa seconde utilité est de pouvoir récupérer la valeur par défaut d’un type valeur ou référence. On y trouve une utilité lors de l’utilisation de générique où on sait déterminer si on a affaire à un type valeur ou référence.

public class MaClasse<T>
{
    public MaClasse(T param)
    {
        Object obj = default(T);

        if (obj == null)
            Console.WriteLine("T est un type référence !");
        else
            Console.WriteLine("T est un type valeur !");
    }
}

static void Main()
{
    MaClasse<int> test1 = new MaClasse<int>(5);
    MaClasse<string> test2 = new MaClasse<string>("Salut");
}

delegate

Le mot clé delegate permet de déclarer un type référence qui permettra d’encapsuler plusieurs méthodes nommées ou anonymes.

delegate void D();

static void MethodA()
{
    Console.WriteLine("Méthode A");
}
static void MethodB()
{
    Console.WriteLine("Méthode B");
}

static void Main()
{
    D monDelegue = new D(MethodA);
    // Affiche :
    // Méthode A
    monDelegue();

    monDelegue += new D(MethodB);
    // Affiche :
    // Méthode A
    // Méthode B
    monDelegue();

    monDelegue -= new D(MethodA);
    // Affiche :
    // Méthode B
    monDelegue();


    D monDelegueAnonyme = delegate { Console.WriteLine("Ceci est une méthode anonyme !"); };
    // Affiche :
    // Ceci est une méthode anonyme !
    monDelegueAnonyme();
}

do

Le mot clé do permet d’exécuter en boucle un bloc d’instructions tant que la condition renvoie vrai. À noter que la condition ne sera vérifiée qu’après avoir exécuté une première fois le bloc d’instruction.

static void Main()
{
    int i = 0;
    do
    {
        i++;
    } while (i < 5);
}

double

Le mot clé double est un alias de la structure System.Double. Vous pourrez stocker dans ce type une valeur à virgule flottante codée sur 64 bits (de 4.9*10^-324 à 1.8*10^308).

double monDoubleAlias = 13.7;
Double = monDoubleStructure = monDoubleAlias;

else

Le mot clé else va de pair avec if. Si la condition du if n’est pas vérifiée, on passera au bloc else.

Boolean valeur = true;
if (valeur == true)
{
    Console.WriteLine("La condition est vraie");
}
else
{
    Console.WriteLine("La condition est fausse");
}

enum

Le mot clé enum permet de déclarer une énumération qui représente un ensemble fini de constantes nommées.

enum Jours
{
    Lundi,
    Mardi,
    Mercredi,
    Jeudi,
    Vendredi,
    Samedi,
    Dimanche
}

event

Le mot clé event permet de déclarer un évènement. Les évènements permettent de notifier des occurrences qu’un état donné a été modifié (clique sur un bouton par exemple).

delegate void TimeEventHandler();

class TestTime
{
    public event TimeEventHandler OnTime;

    public void time()
    {
        OnTime();
    }
}

static class Program
{
    static void Main()
    {
        TestTime monTime = new TestTime();

        // On s'abonne à l'évènement
        monTime.OnTime += new TimeEventHandler(monTime_OnTime);

        // Notification
        monTime.time();
    }

    /// <summary>
    /// Handler de l'évènement onTime
    /// </summary>
    static void monTime_OnTime()
    {
        MessageBox.Show("Evènement !");
    }
}

explicit

Le mot clé explicit permet de déclarer un opérateur explicite de conversion.

public class Franc
{
    public Double Argent;

    public Franc(Double param_Argent)
    {
        Argent = param_Argent;
    }
}

public class Euro
{
    public Double Argent;

    public Euro(Double param_Argent)
    {
        Argent = param_Argent;
    }

    public static explicit operator Euro(Franc param_Franc)
    {
        return new Euro(param_Franc.Argent / 6.55957);
    }
}

static class Program
{
    static void Main()
    {
        Franc mesFranc = new Franc(1000);
        Euro ConversionEuro = (Euro)mesFranc;

        Console.WriteLine("{0} FF = {1} €", mesFranc.Argent, ConversionEuro.Argent);
    }
}

extern

Le mot clé extern permet de déclarer une méthode comme étant implémentée en externe. C’est-à-dire dans une DLL non managée. extern sera le plus souvent utilisé avec l’attribut DllImport.

static class Program
{
    /// <summary>
    /// Permet d'afficher un MessageBox
    /// </summary>
    [DllImport("User32.dll")]
    public static extern int MessageBox(int h, string m, string c, int type);

    static void Main()
    {
        MessageBox(0, "Mon texte", "Mon titre", 0);
    }
}

false

Le mot clé false est un opérateur représentant la valeur faux d’un bool (ou Boolean).

bool monBool = false;

finally

Le mot clé finally est le troisième bloc possible avec un try/catch. Il sera toujours exécuté, peu importe ce qu’il arrive : en quittant le bloc try (normalement ou avec return) ou après le bloc catch suite à une exception.

Le bloc finally est la plupart du temps (pour ne pas dire tout le temps) utilisé pour libérer les ressources allouées dans le bloc try.

static void Main()
{
    ArrayList monTableau = new ArrayList();
    monTableau.Add("5");
    monTableau.Add("9");
    monTableau.Add("s");

    try
    {
        for (int i = 0; i < monTableau.Count; i++)
        {
            int monInt = Convert.ToInt32(monTableau[i]);
        }
    }
    catch (Exception)
    {
        Console.WriteLine("Il y a eu une exception !");
    }
    finally 
    {
        monTableau = null;
    }
}

fixed

Le mot clé fixed est utilisé dans les contexte unsafe, c’est-à-dire avec utilisation de pointeurs. Le .NET Framework peut à tout moment modifier l’emplacement en mémoire de telle ou telle autre variable ce qui pourrait poser problème si on désire parcourir un tableau à partir de l’adresse de la première cellule. fixed va permettre d’empêcher que le Garbage Collector déplace la variable dans la mémoire.

static class Program
{
    unsafe static void Main()
    {
        int[] tab = new int[2007];

        // p pointe sur la première case de tab
        fixed (int* p = tab)
        { 
            Random random = new Random();
            for (int i = 0; i < tab.Length; i++)
                p[i] = random.Next();
        }
    }
}

float

Le mot clé float est un alias de la structure System.Single. Vous pourrez stocker dans ce type une valeur à virgule flottante codée sur 32 bits (de 1.4*10^-45 à 3.4*10^38).

float monFloatAlias = 13.7F;
Single monSingleStructure = monFloatAlias;

for

Le mot clé for permet de répéter une instruction ou un bloc d’instructions tant que l’expression évaluée renvoie vrai.

for (int i = 0; i < 10; i++)
{ 
    Console.WriteLine("{0}", i);
}

La boucle for ci-dessus se déroule comme suit :

  • i est initialisé à 0 ;
  • i est évalué : si i est bien inférieure à 10, on exécute le bloc d’instructions ;
  • Une fois le bloc exécuté, i est incrémenté de 1 ;
  • Pour être une nouvelle fois évalué ;
  • Cette séquence se répètera tant que i sera strictement inférieur à 10

foreach

Le mot clé foreach permet de parcourir une collection afin de récupérer un par un chaque élément afin d’exécuter un bloc d’instructions.

string[] stringTab = { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };

foreach (string str in stringTab)
{
    Console.WriteLine("{0}", str);
}

goto

Le mot clé goto permet de sauter à une instruction étiquetée. Cette pratique est vivement déconseillée, car on peut très vite se retrouver avec un code dont il est difficile de savoir ce qui sera exécuté sous telle ou telle autre condition. On appelle ça la « programmation spaghetti ».

static class Program
{
    static void Main()
    {
        int i = (new Random()).Next();

        if (i % 2 == 0)
            goto Pair;
        else
            goto Impair;


    Pair:
        Console.WriteLine("i est un nombre pair ({0})", i);
        return;

    Impair:
        Console.WriteLine("i est un nombre impair ({0})", i);
        return;

    }
}

if

Le mot clé if permet de tester une ou plusieurs conditions afin d’exécuter un bloc d’instructions dans le cas où la condition est vrai. En cas de condition qui renvoie faux, on passera au test de la condition du bloc suivant (else if) ou au bloc par défaut (else) s’il y en a un.

int i = 0;

if (i == 0)
{
    Console.WriteLine("i vaut {0}", i);
}
else if (i == 1)
{
    Console.WriteLine("i vaut {0}", i);
}
else
{
    Console.WriteLine("i ne vaut ni 0, ni 1");
}

implicit

Le mot clé implicit est utilisé pour déclarer un opérateur de conversion implicite défini dans une classe.

class NombreEntier
{
    public int valeur;
    public NombreEntier(int param)
    {
        valeur = param;
    }

    // Opérateur de conversion en int
    public static implicit operator int(NombreEntier a)
    {
        return a.valeur;
    }
}
static class Program
{
    static void Main()
    {
        NombreEntier monNombre1 = new NombreEntier(5);

        // Conversion
        int monInt = (int)monNombre1;
        Console.WriteLine("monInt vaut {0}", monInt);

    }
}

in

Le mot clé in fonctionne avec le mot clé foreach qui permet de parcourir une collection. in est utilisé pour spécifier la collection dans laquelle il faudra récupérer chaque élément.

string[] stringTab = { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };

foreach (string str in stringTab)
{
    Console.WriteLine("{0}", str);
}

int

Le mot clé int est un alias de la structure System.Int32. Vous pourrez stocker dans ce type une valeur entière signée codée sur 32 bits (de -2^31 à 2^31 – 1).

int monIntAlias = 2007;
Int32 monInt32Structure = monIntAlias;

interface

Le mot clé interface permet de déclarer une interface.

interface MonInterface
{
    void MethodeInterface();
}

internal

Le mot clé internal est un qualificatif qui s’applique aux classes ainsi qu’aux champs et méthodes d’une classe. Dans ce cas, seules les méthodes de la même assembly peuvent avoir accès à un champ ou une méthode qualifiée de internal.

internal class maClasse
{ }

is

Le mot clé is permet de tester si un objet est bien d’un type donné.

object[] mesObjets = { 1, "Salut", 13.7F };

foreach (object obj in mesObjets)
{
    if (obj is int)
        Console.WriteLine("int");
    else if (obj is string)
        Console.WriteLine("string");
    else
        Console.WriteLine("Type inconnu");
}

lock

Le mot clé lock permet de déclarer une section critique dans le cas d’une application multithreads en verrouillant l’accès à un objet. Tout thread qui tentera d’accéder à cette section critique et utiliser par la même occasion l’objet verrouillé se verra bloqué tant que la ressource ne sera pas libérée.

object obj = new object();

lock (obj)
{ 
    // Début section critique
    
    // instructions
    
    // Fin section critique
}

long

Le mot clé long est un alias de la structure System.Int64. Vous pourrez stocker dans ce type une valeur entière signée codée sur 64 bits (de -9.2*10^18 à 9.2*10^18).

long monLongAlias = 1000000000;
Int64 monInt64Structure = monLongAlias;

namespace

Le mot clé namepace sert à spécifier une portée afin d’organiser ses classes. C’est comme si on rangeait les classes dans des dossiers pour avoir une organisation qui permet de s’y retrouver facilement.

namespace MonNamespace.Operations
{
    class Operations
    { }
}
namespace MonNamespace.Operations.Entiers
{
    class Entiers
    { }
}

namespace MonNamespace.Operations.Reels
{
    class Reels
    { }
}

Le Framework Class Library (FCL) de .NET est organisée en namespace afin d’y avoir un accès intuitif avec des noms de namespace significatifs (comme System.xml pour les classes gérant le Xml).

new

Le mot clé new consiste à allouer sur le heap la mémoire nécessaire pour l’objet en question. Les variables allouées sur le heap sont les chaînes de caractères, tableaux et objets tandis que les types valeurs (int, long, bool…) et les structures sont alloués sur la pile.

int[] monTableauInt = new int[5];

null

Le mot clé null permet de mettre une référence à null. Par défaut, une référence vaut null.

// obj1 et obj2 valent null
object obj1;
object obj2 = null;

object

Le mot clé object est un alias de System.Object et représente la classe de base aussi bien pour les objets de type référence que valeur.

class Oiseau
{ }

static class Program
{
    static void Main()
    {
        // Casting d'un type valeur en object
        int monInt = 10;
        object monIntDansObject = monInt;

        // Casting d'un type référence en object
        Oiseau monOiseau = new Oiseau();
        object monOiseauDansObject = monOiseau;
    }
}

operator

Le mot clé operator est utilisé pour définir le comportement d’une classe par rapport à un opérateur arithmétique, de conversion ou encore logique.

class NombreEntier
{
    public int valeur;
    public NombreEntier(int param)
    {
        valeur = param;
    }

    // Opérateur arithmétique +
    public static NombreEntier operator +(NombreEntier a, NombreEntier b)
    {
        return new NombreEntier(a.valeur + b.valeur);
    }

    // Opérateurs logiques == et !=
    public static bool operator ==(NombreEntier a, NombreEntier b)
    {
        return a.valeur == b.valeur;
    }
    public static bool operator !=(NombreEntier a, NombreEntier b)
    {
        return a.valeur != b.valeur;
    }

    // Opérateur de conversion en int
    public static implicit operator int(NombreEntier a)
    {
        return a.valeur;
    }
}
static class Program
{
    static void Main()
    {
        NombreEntier monNombre1 = new NombreEntier(5);
        NombreEntier monNombre2 = new NombreEntier(6);

        // Opération +
        NombreEntier monNombre3 = monNombre1 + monNombre2;
        Console.WriteLine("monNombre3 vaut {0}", monNombre3.valeur);

        // Comparaison
        if (monNombre1 != monNombre3)
            Console.WriteLine("monNombre1 et monNombre3 sont différents");
        else
            Console.WriteLine("monNombre1 et monNombre3 sont égaux");

        // Conversion
        int monInt = (int)monNombre1;
        Console.WriteLine("monInt vaut {0}", monInt);

    }
}

out

Le mot clé out permet de passer un paramètre par référence sans qu’il n’y ait besoin de l’initialiser.

static class Program
{
    static void Main()
    {
        int monInt;

        maFonction(out monInt);

        // monInt vaut 2007
        Console.WriteLine("monInt vaut {0}", monInt);
    }

    static void maFonction(out int param_int)
    {
        param_int = 2007;
    }
}

override

Le mot clé override permet de ré implémenter une méthode virtuelle ou abstraite d’une classe de base dans la classe dérivée.

public class classA
{
    public virtual void ExempleMethode()
    {
        Console.WriteLine("ExempleMethode de classA");
    }
}

public class classB : classA
{
    public override void ExempleMethode()
    {
        Console.WriteLine("Surcharge de ExempleMethode de classB");
    }
}

params

Le mot clé params est utilisé pour passer un nombre variable de paramètres à une fonction.

static void Main()
{
    MaFonctionVariable("Bonjour");
    MaFonctionVariable("Bonjour", "Au revoir");
}

static void MaFonctionVariable(params String[] MesParams)
{
    foreach (String courantString in MesParams)
        Console.WriteLine("Valeur du paramètre : {0}", courantString);
}

private

Le mot clé private est un qualificatif qui s’applique aux classes ainsi qu’aux champs et méthodes d’une classe. Dans ce cas, seules les méthodes de la même classe peuvent y avoir accès ce qui signifie qu’une classe dérivée ne pourra avoir accès à un champ ou une méthode qualifiée de private.

private class maClasse
{ }

protected

Le mot clé protected est un qualificatif qui s’applique aux classes ainsi qu’aux champs et méthodes d’une classe. Dans ce cas, seules les méthodes de la même classe ou des classes dérivées peuvent avoir accès à un champ ou une méthode qualifiée de protected.

protected class maClasse
{ }

public

Le mot clé public est un qualificatif qui s’applique aux classes ainsi qu’aux champs et méthodes d’une classe. Dans ce cas, n’importe quelle méthode de n’importe quelle classe peut avoir accès à un champ ou une méthode qualifiée de public.

public class maClasse
{ }

readonly

Le mot clé readonly permet de qualifier un champ en tant que constante qui pourra être initialisé au plus tard dans le constructeur de la classe.

class TestConstante
{
    readonly string monReadOnly;

    public TestConstante(string monParam)
    {
        monReadOnly = monParam;
    }
}

ref

Le mot clé ref permet de passer un paramètre par référence.

static class Program
{
    static void Main()
    {
        int monInt = 2006;

        // monInt vaut 2006
        Console.WriteLine("monInt avant l'appel de fonction vaut {0}", monInt);

        maFonction(ref monInt);

        // monInt vaut 2007
        Console.WriteLine("monInt après l'appel de fonction vaut {0}", monInt);
    }

    static void maFonction(ref int param_int)
    {
        param_int++;
    }
}

return

Le mot clé return permet de terminer l’exécution d’une méthode voir de retourner une valeur à la méthode appelante.

void ExampleReturn(int param)
{
    if (param == 0)
        // Met fin à l'exécution de la méthode
        return;
}

int ExampleReturnValeur(int param)
{
    // retourne le carré de la valeur passée en paramètre
    return param * param;
}

sbyte

Le mot clé sbyte est un alias de la structure System.SByte. Vous pourrez y stocker une valeur entière signée codée sur 8 bits (de -128 à 127).

sbyte monsByteAlias = -5;
SByte = monSByteStructure = monsByteAlias;

sealed

Le mot clé sealed permet d’empêcher une classe d’être dérivée.

sealed class ClassImpossibleAHeriter
{ 
    // ...
}

short

Le mot clé short est un alias de la structure System.Int16. Vous pourrez stocker dans ce type une valeur entière signée codée sur 16 bits (de -2^15 à 2^15 – 1).

short monShortAlias = 2007;
Int16 monInt16Structure = monShortAlias;

sizeof

Le mot clé sizeof permet de récupérer la taille en octet d’un type valeur.

static class Program
{
    static void Main()
    {
        Console.WriteLine("byte vaut {0} octets", sizeof(byte));
        Console.WriteLine("short vaut {0} octets", sizeof(short));
        Console.WriteLine("int vaut {0} octets", sizeof(int));
        Console.WriteLine("long vaut {0} octets", sizeof(long));
    }
}

stackalloc

Le mot clé stackalloc est utilisé dans un contexte unsafe et permet d’allouer un bloc de mémoire sur la pile.

int* psa = stackalloc int[100];

static

Le mot clé static permet de qualifier des champs comme des méthodes d’une classe qui existent sans instance de la classe. Ils sont donc communs à toutes les instances d’une classe.

Pour y accéder, on utilisera le nom de la classe.

static class Program
{
    static void Main()
    {
        // "Le compteur vaut 0"
        ExempleStatic.AfficheCompteur();

        ExempleStatic monObj1 = new ExempleStatic();

        // "Le compteur vaut 1"
        ExempleStatic.AfficheCompteur();

        ExempleStatic monObj2 = new ExempleStatic();

        // "Le compteur vaut 2"
        ExempleStatic.AfficheCompteur();
    }
}

/// <summary>
/// Classe qui compte le nombre d'instances
/// </summary>
class ExempleStatic
{
    static int Compteur = 0;

    public ExempleStatic()
    {
        Compteur++;
    }

    public static void AfficheCompteur()
    {
        Console.WriteLine("Le compteur vaut {0}", Compteur);
    }
}

string

Le mot clé string est un alias de System.String et permet de stocker une chaîne de caractères. Malgré le fait que ce soit un type référence, à chaque opération, un nouveau string est créé.

static class Program
{
    static void Main()
    {
        string monString = "Bonjour";
        System.String monStringAlias = monString;

        // "Le string vaut Bonjour"
        Console.WriteLine("Le string vaut {0}", monStringAlias);

        // "Le string vaut Bonjour tout le monde !!!"
        AfficheString(monStringAlias);

        // La référence n'a pas été modifiée
        // "Le string vaut Bonjour"
        Console.WriteLine("Le string vaut {0}", monStringAlias);
    }

    static void AfficheString(string param_String)
    {
        param_String = param_String + " tout le monde !!!";
        Console.WriteLine("Le string vaut {0}", param_String);
    }
}

La technique pour contourner ce problème est de passer la référence de la référence elle-même avec ref ou out :

static void Main()
{
    //...

    // La référence a enfin été modifiée
    // "Le string vaut Bonjour tout le monde !!!"
    Console.WriteLine("Le string vaut {0}", monStringAlias);
}

static void AfficheStringRef(ref string param_String)
{
    param_String = param_String + " tout le monde !!!";
}

struct

Le mot clé struct sert à déclarer une structure.

struct ExempleStructure
{
    int monInt;
    long monLong;
}

À noter qu’une structure est un type valeur étant donné qu’elle dérive de System.ValueType.

switch

Le mot clé switch permet de faire un aiguillage vers une ou plusieurs instructions en fonction d’une variable de contrôle. La variable de contrôle peut être une valeur entière (byte, short, int, long), un caractère (char), une chaîne de caractères (string) ou encore une valeur d’énumération.

switch ((new Random()).Next(5))
{
    case 0: Console.WriteLine("La valeur vaut 0"); break;
    case 1: Console.WriteLine("La valeur vaut 1"); break;
    case 2: Console.WriteLine("La valeur vaut 2"); break;
    case 3: Console.WriteLine("La valeur vaut 3"); break;
    default: Console.WriteLine("La valeur n'est pas gérée"); break;
}

this

Le mot clé this est utilisé pour faire référence à l’objet en cours et ainsi accéder aux membres de l’objet en question.

class ExempleThis
{
    private String MonString;
    
    public ExempleThis()
    {
        MonString = "Hello";
    }

    private String ReturnWorld()
    {
        return "World";
    }

    public void DisplayHelloWorld()
    {
        Console.WriteLine(this.MonString + " " + this.ReturnWorld());
    }
}

throw

Le mot clé throw permet de lever une exception afin de signaler un problème.

void ExempleMethode(int param_Int)
{
    if (param_Int == 0)
        throw new Exception("Le paramètre ne peut être egal à 0 !!!");
}

true

Le mot clé true est un opérateur représentant la valeur vrai d’un bool (ou Boolean).

bool monBool = true;

try

Le mot clé try permet d’englober un bloc d’instructions qui est dit « protégé ». C’est-à-dire que si une exception est levée dans ce bloc, elle sera traitée dans un des blocs catch qui suit.

try
{
    int i = 0;
    int j = 5;

    int ret = j / i;
}
catch (DivideByZeroException exc) 
{
    Console.WriteLine("Voici le message de l'erreur : {0}", exc.Message);
}

typeof

Le mot clé typeof permet de récupérer un objet System.Type sur base d’un type.

Type monType = typeof(int);

uint

Le mot clé uint est un alias de la structure System.UInt32. Vous pourrez stocker dans ce type une valeur entière non signée codée sur 32 bits (de 0 à 4294967295).

uint monUIntAlias = 2007;
UInt32 monUInt32Structure = monUIntAlias;

ulong

Le mot clé ulong est un alias de la structure System.UInt64. Vous pourrez stocker dans ce type une valeur entière non signée codée sur 64 bits (de 0 à 18*10^18).

ulong monULongAlias = 1000000000;
UInt64 monUInt64Structure = monULongAlias;

unchecked

Le mot clé unchecked permet de désactiver le contrôle de dépassement de capacité sur des entiers ou lors de conversion.

unchecked
{
    int i = int.MaxValue + 1;
}

Sans le mot clé unchecked, l’instruction ne passerait même pas à la compilation, car il s’agit d’une opération sur des constantes.

unsafe

Le mot clé unsafe permet de déclarer un bloc d’instructions pouvant utiliser les pointeurs.

unsafe
{
    int i = 2006, j;
    int* k;

    // k pointe sur i
    k = &i;

    // j contient 2007
    j = *k + 1;
}

À noter que pour utiliser les pointeurs dans un projet, il faut au préalable les activer. Pour cela, allez dans les propriétés du projet, sélectionnez l’onglet « Build » et cochez la case « allow unsafe code ».

ushort

Le mot clé ushort est un alias de la structure System.UInt16. Vous pourrez stocker dans ce type une valeur entière non signée codée sur 16 bits (de 0 à 65535).

ushort monUShortAlias = 2007;
UInt16 monUInt16Structure = monUShortAlias;

using

Il y a trois utilisations pour le mot clé using.

Première utilisation: permettre l’utilisation de types dans un espace de noms :

using System;

namespace WindowsApplication3
{
    static class Program
    {
        static void Main()
        {
            System.Object obj1 = new System.Object();
            // ou
            Object obj2 = new Object();
        }
    }
}

Seconde utilisation : créer un alias en rapport avec un espace de noms :

using System;

using MonAlias = System.Object;

namespace WindowsApplication3
{
    static class Program
    {
        static void Main()
        {
            System.Object obj1 = new System.Object();
            // ou
            MonAlias obj2 = new MonAlias();
        }
    }
}

Troisième utilisation : définir la portée d’existence d’un objet. Pour être plus précis, la méthode Dispose de l’objet en question sera appelée automatiquement une fois que le bloc d’instructions sera terminé. Ce qui implique donc que l’objet utilisé dans un using devra implémenter l’interface IDisposable :

class Oiseau : IDisposable
{
    public void Dispose()
    { }
}

static class Program
{
    static void Main()
    {
        Oiseau monOiseau = new Oiseau();

        using (monOiseau)
        { }
    }
}

virtual

Le mot clé virtual est utilisé pour les méthodes, indexeurs, propriétés et évènements signifiant que ces derniers peuvent être réimplémentés dans une classe dérivée.

public class classA
{
    public virtual void ExempleMethode()
    {
        Console.WriteLine("ExempleMethode de classA");
    }
}

public class classB : classA
{
    public override void ExempleMethode()
    {
        Console.WriteLine("Surcharge de ExempleMethode de classB");
    }
}

volatile

Le mot clé volatile est utilisé sur les champs qui sont accédés par plusieurs threads différents. Cela permet que la dernière valeur du champ soit toujours présente.

public volatile string monStringVolatile = "Ma chaîne";

void

Le mot clé void est utilisé pour signaler qu’une méthode ne renvoie aucune valeur.

void ExempleMethode()
{ }

while

Le mot clé while représente une boucle. Tant que la condition renvoie vrai, le bloc d’instructions est exécuté. La condition est vérifiée avant d’exécuter le bloc d’instructions pour la première fois.

int i = 0;
while (i < 5)
{
    Console.WriteLine("i vaut {0}", i);

    i++;
}

Remerciements

Je tiens à remercier Dider Danse pour son aide et sa patience ainsi que Nicolas Jolet pour ses corrections.