FAQ C#Consultez toutes les FAQ

Nombre d'auteurs : 41, nombre de questions : 272, dernière mise à jour : 1er novembre 2017  Ajouter une question

 

Cette FAQ a été réalisée pour répondre aux questions les plus fréquemment posées concernant C# sur le forum Développement DotNET

Je tiens à souligner qu'elle ne garantit en aucun cas que les informations qu'elle contient sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.

Commentez cette FAQ : Commentez


SommaireLe langage C#Opérations de base (13)
précédent sommaire suivant
 

Il y a deux manières d'écrire des commentaires de code en C# :

  • // ... Toute la ligne sera en commentaire.
  • /* ... */ Tout ce qui est contenu entre /* et */ sera en commentaire. Ce type de commentaire peut s'étendre sur plusieurs lignes.

Il existe une troisième forme de commentaire, utilisée pour documenter le code :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
/// <summary> 
/// description de la classe 
/// </summary> 
class MaClasse 
{ 
    // ... 
}
Une option du compilateur permet d'extraire tous les commentaires de documentation du code dans un fichier XML, qui peut ensuite être utilisé par des outils pour générer des pages de documentation.

Mis à jour le 2 janvier 2007 Jérôme Lambert tomlev

La méthode Main est le point d'entrée de tout programme. Il existe 4 signatures différentes :

Code c# : Sélectionner tout
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; } 
}

Contrairement à ce que vous pourriez penser, il n'y a pas 6 signatures possibles mais bien 4 car il n'est pas possible d'utiliser la classe de base Object à la place de String.

Mis à jour le 20 mars 2007 Jérôme Lambert

En C#, il est possible d'accéder explicitement aux membres de l'objet courant par l'intermédiaire du mot réservé this. Cela permet notamment de lever une ambiguïté si une variable locale ou un paramètre porte le même nom qu'un membre de l'objet courant :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
class ExempleThis 
{ 
    private String monString; 
  
    public ExempleThis(string monString) 
    { 
        this.monString = monString; 
    } 
}
Le mot-clé this permet également de faire référence à l'objet courant, par exemple pour le passer à une autre classe :

Code c# : Sélectionner tout
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; } 
}

Mis à jour le 10 janvier 2007 Jérôme Lambert tomlev

Bien que cela soit déconseillé, il est possible d'utiliser un mot-clé réservé en le préfixant du caractère @ :

Code c# : Sélectionner tout
1
2
3
4
void @while() 
{ 
    int @class = 2007; 
}

Mis à jour le 2 janvier 2007 Jérôme Lambert tomlev

Il existe 2 solutions pour déterminer si un objet est d'un type donné :

La première est d'utiliser le mot-clé is. Ce dernier renvoie vrai si l'objet est bien du type demandé :

Code c# : Sélectionner tout
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 !");

Une seconde solution est d'utiliser as. La différence est que as va tenter de faire le cast de l'objet vers le type spécifié. Si le cast n'est pas valide, null sera renvoyé :

Code c# : Sélectionner tout
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 !"); 
}
Notez que le mot-clé as ne peut être utilisé qu'avec un type référence, puisque les objets de type valeur ne peuvent pas valoir null.

Mis à jour le 10 janvier 2007 Jérôme Lambert tomlev

Pour utiliser un tableau, en C#, vous devez faire suivre le type des éléments du tableau par [].
Pour accéder aux éléments du tableau, vous devez le parcourir en utilisant les index.

Attention, le premier indice des éléments d'un tableau commence à 0 et pas à 1
Code c# : Sélectionner tout
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]); 
        } 
    } 
}

Mis à jour le 2 novembre 2004 abelman Thomas Lebrun

Vous pouvez effectuer un décalage à gauche ou droite d'un certain nombre de bits à l'aide des opérateurs << et >> :

Code c# : Sélectionner tout
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);

Mis à jour le 2 janvier 2007 Jérôme Lambert tomlev

Le mot-clé default permet d'obtenir la valeur par défaut d'un type. Pour un type référence, la valeur par défaut est toujours null. Pour un type valeur, la valeur par défaut est une instance du type où tous les champs ont leur valeur par défaut (tous les octets à 0).

Code c# : Sélectionner tout
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");
Ce mot-clé est particulièrement pratique quand on écrit une classe ou une méthode générique.

Mis à jour le 20 mars 2007 Jérôme Lambert tomlev

La différence entre 2 dates s'effectue à l'aide de l'opérateur -, qui est redéfini dans le type DateTime pour renvoyer un objet de type TimeSpan (intervalle de temps).
Calculons le nombre de jours écoulés depuis la création de cette question :

Code c# : Sélectionner tout
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);
Notez que divers opérateurs arithmétiques sont également redéfinis dans les structures DateTime et TimeSpan, si bien qu'on peut effectuer diverses opérations sur les dates.

  • DateTime - DateTime = TimeSpan
  • DateTime + TimeSpan = DateTime
  • DateTime - TimeSpan = DateTime
  • TimeSpan + TimeSpan = TimeSpan
  • DateTime + DateTime = impossible car cela n'a pas de sens

Mis à jour le 2 janvier 2007 Jérôme Lambert tomlev

Un type valeur, par définition, ne peut pas être null : il a forcément une valeur. Il existe cependant un type générique Nullable<T> qui permet d'englober un type valeur, et qui peut valoir null :

Code c# : Sélectionner tout
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; 
}

Mis à jour le 20 mars 2007 Jérôme Lambert tomlev

En utilisant les mot-clés ref et out. La différence entre ref et out est la suivante :

  • Avec ref, l'initialisation du paramètre est de la responsabilité du code appelant. La méthode n'est pas obligée de modifier la valeur du paramètre.
  • Avec out, l'initialisation de la variable est de la responsabilité de la méthode, qui doit obligatoirement lui affecter une valeur avant de se terminer. Le code appelant n'est pas obligé de l'initialiser.

Voici un exemple pour clarifier tout ça :

Code c# : Sélectionner tout
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"); 
    } 
}

Mis à jour le 2 novembre 2004 Thomas Lebrun tomlev

Il est très facile de s'abonner à un évènement de l'interface graphique à l'aide du designer, mais qu'en est-il quand on veut le faire soi-même dans le code ? Il suffit pour cela d'utiliser l'opérateur += :

Code c# : Sélectionner tout
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 !"); 
}
Notez qu'on indique le type de delegate défini pour l'évènement (EventHandler dans ce cas). La signature (type de retour et types des paramètres) de la méthode utilisée pour s'abonner doit correspondre à la signature de ce delegate.

Depuis C# 2, il n'est plus nécessaire de spécifier le type de delegate, on peut donc écrire simplement :

Code c# : Sélectionner tout
monObjet.MonEvenement += monObjet_MonEvenement;
Cependant la règle de correspondance des signatures s'applique toujours.

Pour se désabonner d'un évènement, on utilise l'opérateur -= :

Code c# : Sélectionner tout
monObjet.MonEvenement -= monObjet_MonEvenement;

Mis à jour le 8 mars 2010 tomlev

Une méthode anonyme est une méthode sans nom qui peut être créée à l'intérieur d'une autre méthode. Le résultat obtenu est en fait un delegate, qui peut être affecté à une variable ou passé en paramètre d'une méthode.
Voyons un exemple plus parlant :

Code c# : Sélectionner tout
1
2
3
4
monButton.Click += delegate 
{ 
    MessageBox.Show("Une méthode anonyme"); 
};
On peut aussi spécifier les paramètres au cas où on aurait besoin de les utiliser :

Code c# : Sélectionner tout
1
2
3
4
monButton.Click += delegate(object sender, EventArgs e) 
{ 
    MessageBox.Show("Une méthode anonyme"); 
};
La version 3 de C# introduit une nouvelle syntaxe pour déclarer des méthodes anonymes, appelée « expression lambda » :

Code c# : Sélectionner tout
1
2
3
4
monButton.Click += (sender, e) => 
{ 
    MessageBox.Show("Une méthode anonyme"); 
};

Mis à jour le 10 avril 2006 dev01 tomlev

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Microsoft DotNET : Hinault Romaric -