FAQ C#Consultez toutes les FAQ

1
2
3
4
5
6
7
/// <summary> 
/// description de la classe 
/// </summary> 
class MaClasse 
{ 
    // ... 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class DifferentsMain 
{ 
    // Méthode sans paramètres 
    // Ni code de retour 
    public static void Main() 
    { } 
  
    // Méthode sans paramètres 
    // Avec code de retour 
    public static int Main() 
    { return 0; } 
  
    // Méthode avec paramètres 
    // Mais sans code de retour 
    public static void Main(params String[] param) 
    { } 
  
    // Méthode avec paramètres 
    // Et code de retour 
    public static int Main(params String[] param) 
    { return param.Length; } 
}

1
2
3
4
5
6
7
8
9
class ExempleThis 
{ 
    private String monString; 
  
    public ExempleThis(string monString) 
    { 
        this.monString = monString; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Parent 
{ 
    private List<Enfants> _enfants = new List<Enfant>(); 
  
    public IEnumerable<Enfant> Enfants 
    { 
        get { return _enfants; } 
    } 
  
    public Enfant AddEnfant() 
    { 
        Enfant e = new Enfant(this); // On passe l'objet courant en paramètre 
        _enfants.Add(e); 
        return e; 
    } 
} 
  
class Enfant 
{ 
    public Enfant(Parent parent) 
    { 
        this.Parent = parent; 
    } 
  
    public Parent Parent { get; private set; } 
}

1
2
3
4
void @while() 
{ 
    int @class = 2007; 
}

1
2
3
4
5
String monString = "Ceci est un test !"; 
if (monString is String) 
    Console.WriteLine("monString est bien de type String !"); 
  else 
    Console.WriteLine("monString n'est pas de type String !");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Customer 
{ } 
class Vendor 
{ } 
  
public static void Main() 
{ 
    Object obj = new Vendor(); 
  
    Object testCustomer = obj as Customer; 
    Object testVendor = obj as Vendor; 
  
    if (testCustomer == null) 
        Console.WriteLine("L'objet testé n'est pas de type Customer !"); 
    else 
        Console.WriteLine("L'objet testé est de type Customer !"); 
  
    if (testVendor == null) 
        Console.WriteLine("L'objet testé n'est pas de type Vendor !"); 
    else 
        Console.WriteLine("L'objet testé est de type Vendor !"); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Tableau 
{ 
    // Tableau de type chaine 
    private string[] _TableauString; 
  
    public static void Main() 
    { 
        // On définit la taille du tableau 
        _TableauString = new string[3]; 
  
        // On remplit le tableau 
        for (int i = 0; i < 3; i++) 
        { 
            _TableauString[i] = "Chaine " + i; 
        } 
  
        // Affichage du contenu du tableau 
        for (int i = 0; i < 3; i++) 
        { 
            Console.Write("Case " + i); 
            Console.WriteLine("Contenu: " + _TableauString[i]); 
        } 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int value = 8; 
int res; 
  
Console.WriteLine("La valeur de départ vaut {0}", value); 
  
// Décalage vers la gauche 
// res est multiplié par 2 
res = value << 1; 
Console.WriteLine("Après un décalage de 1 vers la gauche, res vaut {0}", res); 
  
// Décalage vers la droite 
// res est divisé par 2 
res = value >> 1; 
Console.WriteLine("Après un décalage de 1 vers la droite, res vaut {0}", res); 
  
// Décalage vers la gauche 
// res est multiplié par 4 
res = value << 2; 
Console.WriteLine("Après un décalage de 2 vers la gauche, res vaut {0}", res);

1
2
Console.WriteLine("Valeur par défaut de int : {0}", default(int) != null ? default(int).ToString() : "NULL"); 
Console.WriteLine("Valeur par défaut de string : {0}", default(string) != null ? default(string).ToString() : "NULL");

1
2
3
4
5
DateTime DateCourante = DateTime.Now; 
DateTime DateCreationquestion = new DateTime(2007, 1, 3); 
  
TimeSpan Ts = DateCourante - DateCreationquestion; 
Console.WriteLine("Il s'est écoulé {0} jour(s) depuis la création de cette question !", Ts.Days);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Entier non nullable 
int monInt1 = 42; 
  
// Entier nullable 
Nullable<int> monInt2 = null; 
  
// Entier nullable, notation abrégée 
int? monInt3 = null; 
  
// Conversion implicite de int vers Nullable<int> 
monInt2 = monInt1; 
  
// Copie d'un Nullable<int> vers un int 
if (monInt2.HasValue) 
{ 
    // Pas de conversion implicite de Nullable<int> vers int, on utilise la propriété Value 
    monInt1 = monInt2.Value; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class TestRef 
{ 
    public void TestRef(ref int i) 
    { 
        if (i < 0) 
            i = 0; 
    } 
  
    public void TestOut(out int j) 
    { 
        j = 5; 
    } 
  
    public static void Main() 
    { 
        // On initialise l'entier a 
        int a = -3; 
        // On le passe en paramètre à la fonction, par référence 
        TestRef(ref a); 
        Console.WriteLine("a vaut maintenant 1"); 
  
        // Utilisation de out 
        int b; 
        // On passe b en paramètre sans l'avoir initialisé 
        TestOut(b); 
        Console.WriteLine("b vaut maintenant 5"); 
    } 
}

1
2
3
4
5
6
7
8
monObjet.MonEvenement += new EventHandler(monObjet_MonEvenement); 
  
// ... 
  
private void monObjet_MonEvenement(object sender, EventArgs e) 
{ 
   Console.WriteLine("MonEvenement s'est produit !"); 
}

monObjet.MonEvenement += monObjet_MonEvenement;

monObjet.MonEvenement -= monObjet_MonEvenement;

1
2
3
4
monButton.Click += delegate 
{ 
    MessageBox.Show("Une méthode anonyme"); 
};

1
2
3
4
monButton.Click += delegate(object sender, EventArgs e) 
{ 
    MessageBox.Show("Une méthode anonyme"); 
};

1
2
3
4
monButton.Click += (sender, e) => 
{ 
    MessageBox.Show("Une méthode anonyme"); 
};