void While()
{
    int iF = 0;
}

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

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

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

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

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

bool monBoolAlias = true;
Boolean monBooleanStructure = monBoolAlias;

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 monByteAlias = 5;
Byte = monByteStructure = monByteAlias;

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

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

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

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

const int maConstante = 2007;

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 monDecimalAlias = 9.1m;
Decimal monDecimalStructure = monDecimalAlias;

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

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

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

double monDoubleAlias = 13.7;
Double = monDoubleStructure = monDoubleAlias;

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

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

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

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

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

bool monBool = false;

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

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 monFloatAlias = 13.7F;
Single monSingleStructure = monFloatAlias;

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

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

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

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;

    }
}

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

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

    }
}

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

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

int monIntAlias = 2007;
Int32 monInt32Structure = monIntAlias;

interface MonInterface
{
    void MethodeInterface();
}

internal class maClasse
{ }

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

object obj = new object();

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

long monLongAlias = 1000000000;
Int64 monInt64Structure = monLongAlias;

namespace MonNamespace.Operations
{
    class Operations
    { }
}

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

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

int[] monTableauInt = new int[5];

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

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

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

    }
}

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

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

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 class maClasse
{ }

protected class maClasse
{ }

public class maClasse
{ }

class TestConstante
{
    readonly string monReadOnly;

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

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

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 monsByteAlias = -5;
SByte = monSByteStructure = monsByteAlias;

sealed class ClassImpossibleAHeriter
{ 
    // ...
}

short monShortAlias = 2007;
Int16 monInt16Structure = monShortAlias;

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

int* psa = stackalloc int[100];

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'instance
/// </summary>
class ExempleStatic
{
    static int Compteur = 0;

    public ExempleStatic()
    {
        Compteur++;
    }

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

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

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 ExempleStructure
{
    int monInt;
    long monLong;
}

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

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

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

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

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

bool monBool = true;

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

Type monType = typeof(int);

uint monUIntAlias = 2007;
UInt32 monUInt32Structure = monUIntAlias;

ulong monULongAlias = 1000000000;
UInt64 monUInt64Structure = monULongAlias;

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

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

    // k pointe sur i
    k = &i;

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

ushort monUShortAlias = 2007;
UInt16 monUInt16Structure = monUShortAlias;

using System;

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

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

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

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

        using (monOiseau)
        { }
    }
}

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

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

void ExempleMethode()
{ }

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

    i++;
}