nicot3m

Commencer

Prérequis avant de commencer

Dans ce chapitre, nous allons voir comment installer l'IDE, tester notre première programme et écrire des commentaires.

Environnement

IDE Visual Studio sous Windows 10

Site pour télécharger Visual Studio
Choisir Community 2022
Puis lors de l'installation sélectionner Développement .NET Desktop.
⚠️ A partir de la version 6, les fonctionnalités C# récentes de haut niveau simplifient le code.
J'utilise la version 8 de .NET.

Mon premier programme

Hello world

Ouvir Visual Studio et créer un nouveau projet
Dans la barre de recherche taper console et choisir Application console C#.
Nommer le projet HelloWorld.
La méthode Console.WriteLine permet d'afficher du texte dans la console.
La méthode Console.ReadKey(true) permet de laisser ouvert la console.
Dans Program.cs écrire le code suivant.


1 Console.WriteLine("Hello World!");
2 Console.ReadKey(true);

output

```
Hello world!
```

Les commentaires

Il y a deux moyens pour rajouter des commentaires.

Une ligne de commentaires

Avec les doubles slash

```
1 // Une ligne de commentaires
```

Plusieurs lignes de commentaires

Avec slash étoile


1 /*
2 Commentaire
3 sur plusieurs lignes
4 */

Les variables

Une variable est un conteneur pour stocker une valeur.

Dans ce chapitre, nous allons voir le déclaration, les différents types et comment les utiliser.

Déclaration

La déclaration permet de nommer et typer la variable.

Pour déclarer une variable, on écrit typeVariable nomVariable.
Le nom d'une variable suit la convention camelCase avec la première lettre en minuscule.
L'initialisation est l'action d'assigner une valeur pour la première fois à une variable.
Pour initialiser une variable on écrit nom variable = valeurInitiale.

Déclaration puis initialisation

						
1 int age;
2 age = 44;
3 Console.WriteLine(age);

output

```
44
```

Déclaration et initialisation simultanées

						
1 int age = 44;
3 Console.WriteLine("age = " + age);

output

```
44
```

Déclaration d'une constante

Si la valeur de la variable est fixe, il est conseillé de la définir comme une constante avec le mot clé const.

						
1 const double pi = 3.44;
3 Console.WriteLine("pi = " + pi);

output

```
44
```

Les types de variables

C# est un langage fortement typé.

Il est obligatoire de déclarer le type et il ne peut pas être modifié ensuite.

Le tableau suivant présentes les principaux types de variables.

Type	Détail
int	nombres entiers
double	nombres décimaux
char	caractère
string	chaîne de caractères
bool	booléen true ou false

La méthode GetType permet de connaître le type d'une variable.


1 Console.WriteLine("La variable age est de type: " + age.GetType());

output


La variable age est de type: System.Int32

Les nombres

Les nombres sont principalement de type int ou double.

Voici un exemple de déclaration.


1 double saving = 100.62;					
2 Console.WriteLine(saving);

output

```
100.62
```

Opérations arythmétiques

Voyons les différentes opérations possibles.

L'addition

						
1 int a = 2;
2 int b = 3;
3 int c = a + b;
4 Console.WriteLine(c);

output

```
5
```

La soustraction

						
1 int a = 2;
2 int b = 3;
3 int c = b - a;
4 Console.WriteLine(c);

output

```
1
```

La multiplication

						
1 int a = 2;
2 int b = 3;
3 int c = a * b;
4 Console.WriteLine(c);

output

```
6
```

La division

						
1 double a = 2;
2 double b = 3;
3 double c = b / a;
4 Console.WriteLine(c);

output

```
1.5
```

Le reste

						
1 int a = 2;
2 int b = 3;
3 int c = b % a;
4 Console.WriteLine(c);

output

```
1
```

L'incrémentation

						
1 int a = 2;
2 a++;
3 Console.WriteLine(a);

output

```
3
```

La décrémentation

						
1 int a = 2;
2 a--;
3 Console.WriteLine(a);

output

```
1
```

Convertir en entier avec les méthodes int.Parse ou int.TryParse

Dans l'exemple suivant, on convertit pointsStr en entier avec la méthode int.Parse.

						
1 string pointsStr = "12";
2 int points = int.Parse(pointsStr)
3 Console.WriteLine(points);

output

```
12
```

Le texte

Le texte est de type string.

Voici un exemple de déclaration.


1 string name = "toto";					
2 Console.WriteLine(name);

output

```
toto
```

La concaténation

L'opérateur + permet de concaténer des chaines de caractères.


1 string firstname = "Paul";
2 string lastname = "Dupont";				
3 Console.WriteLine("Je m'appelle " + firstname + " " + lastname + ".");

output

```
Je m'appelle Paul Dupont.
```

Les booléens

Un booléen est de type bool.

Les booléens sont très utiles dans les conditions que nous verrons plus tard.

Voici un exemple de déclaration.


1 bool condition1 = true;					
2 Console.WriteLine(condition1);

output

```
True
```

La portée des variables

La portée d'une variable est le bloc de code où la variable peut-être utilisée.

La portée d'une variable peut être locale ou globale.
On peut aussi utiliser les contrôles d'accès présentés dans le tableau suivant.

Contrôle d'accès	Accessibilité
public	Partout
private	A l'intérieur du block ou de sa classe
internal	A l'intérieur de son package
protected	A l'intérieur de sa classe et de ses classes héritées.

Les variables de type valeur ou référence

Une variable de type valeur stocke une valeur alors qu'une variable de type référence stocke une référence vers une valeur.
Les types int, double, char, bool et enumeration sont de type valeur.
Les types list, ensemble, tableau et les classes sont de type référence, aussi appelé pointeur.
⚠️, le type string est un type référence mais il ressemble à un type valeur.

Dans l'exemple suivant, changer la valeur de a ne change pas la valeur de b car int est un type valeur.

			
1 int a = 1, b = a;
2 Console.WriteLine("a = " + a + ",b = " + b);
3 a = 2;
4 Console.WriteLine("a = " + a + ",b = " + b);

output

```
a = 1,b = 1
a = 2,b = 1
```

Dans l'exemple suivant, joueur1 et joueur2 sont dans la même équipe.
Logiquement, changer le maillot de joueur2 change aussi le maillot de joueur1 car une classe est de type référence.


1 Joueur joueur1 = new Joueur(), joueur2 = joueur1;
2 Console.WriteLine("joueur1 maillot " + joueur1.maillot, "joueur2 maillot " + joueur2.maillot);
3 joueur2.maillot = "jaune";
4 Console.WriteLine("joueur1 maillot " + joueur1.maillot, "joueur2 maillot " + joueur2.maillot);
5 public class Joueur { public String maillot = "violet"; }

output


joueur1 maillot violet, joueur2 maillot violet
joueur1 maillot jaune, joueur2 maillot jaune

Les structures de données

Dans ce chapitre, nous allons voir les tableaux, les matrices, les listes, les ensembles, les dictionnaires et les énumérations.

Les tableaux

Un tableau(array) est une structure de données permettant de stocker un nombre fixe d'éléments de même type.

Déclaration avec la syntaxe type[] mon_tableau

Dans l'exemple suivant, on déclare le tableau vide monTableau de type string.

```
						
1 string[] monTableau;
```

Création et initialisation d'un tableau à n éléments avec l'opérateur new

Dans l'exemple suivant, on crée le tableau notes avec 3 éléments nuls, puis on affecte la note 12 à l'index 1.

						
2 int[] notes = new int[3];
3 notes[1] = 12;

Afficher un élément d'un tableau avec l'index entre crochets

Dans l'exemple suivant, on affiche la note d'index 1 du tableau des notes.

```
						
4 Console.WriteLine(notes[1]);
```

output

```
12
```

Création d'un tableau rempli avec les valeurs entre accolades

Dans l'exemple suivant, on crée le tableau boules et on lui affecte les valeurs 12, 15 et 7 en une seule ligne de commande.

						
5 int[] boules = new int[]{ 12, 15, 7 };

Boucler sur les éléments d'un tableau avec l'instruction d'itération foreach

Dans l'exemple suivant, on boucle sur le tableau des boules et on affiche chaque valeur dans la console.

						
6 foreach (int boule in boules) { Console.WriteLine(boule); }

output

```
12
15
7 
```

Les matrices

Une matrice est un tableau à 2 dimensions.

Création d'une matrice avec la synthaxe [,]

Dans l'exemple suivant, on crée la matrice places avec 3 lignes et 2 colonnes.

						
1 string[,] places = new string[3,2];
1 places[2, 1] = "Bob"
1 Console.WriteLine(places[2, 1]);

output

```
Bob 
```

Les listes

Une liste est une structure de données permettant de stocker un nombre variables d'éléments de même type.

Création d'une liste avec l'interface IList et la classe List

Dans l'exemple suivant, on crée la liste vide ma_liste de type string.

						
1 IList<string> maListe = new List<string>();

Création d'une liste seulement avec la classe List

Reprenons l'exemple précédent en remplaçant IList par List.

						
1 List<string> maListe = new List<string>();

Création d'une liste avec des éléments

Dans l'exemple suivant, on crée la liste de températures de type double avec les température 8.9 et 15.2.

						
2 IList<double> temperatures = new List<double> { 8.9, 15.2 };

Ajouter un élément à la fin d'une liste avec la méthode Add

Dans l'exemple suivant, on ajoute la température 12.7 à la liste des températures.

```
						
3 temperatures.Add(12.7);
```

Insérer un élément à un index d'une liste avec la méthode Insert

Dans l'exemple suivant, on ajoute la température 13.2 à l'index 1 de la liste des températures.

```
						
4 temperatures.Insert(1, 13.2);
```

Afficher un élément d'une liste avec l'index entre crochets

Dans l'exemple suivant, on affiche la température d'index 2 de la liste des températures.

						
5 Console.WriteLine(temperatures[2]);

output

```
15.2
```

Compter le nombre d'éléments d'une liste avec la propriété count

Dans l'exemple suivant, on compte le nombre d'éléments de la liste des températures.

						
6 Console.WriteLine(temperatures.Count);

output

```
4
```

Retirer un élément d'une liste avec la méthode Remove

Dans l'exemple suivant, on retire la température 12.7 de la liste des températures.

```
						
7 temperatures.Remove(12.7);
```

Retirer un élément à un index d'une liste avec la méthode RemoveAt

Dans l'exemple suivant, on retire la température à l'index 1 de la liste des températures.

```
						
8 temperatures.RemoveAt(1);
```

Boucler sur les éléments d'une liste avec l'instruction d'itération foreach

Dans l'exemple suivant, on boucle sur la liste des températures et on affiche chaque température dans la console.

						
9 foreach (double temperature in temperatures) { Console.WriteLine(temperature); }

output

```
8.9
13.2
```

Les ensembles

Un ensemble est une structure de données permettant de stocker un nombre variables d'éléments de même type non ordonnés et uniques.

Création d'une ensemble avec l'interface ISet et la classe HashSet

Dans l'exemple suivant, on crée l'ensemble vide tarifs de type double.

						
1 ISet<double> tarifs = new HashSet<double>();

Ajouter un élément à un ensemble avec la méthode Add

Dans l'exemple suivant, on ajoute les tarifs 20, 12.5 et 6.65 à la liste des tarifs.

						
2 tarifs.Add(20);
3 tarifs.Add(12.5);
3 tarifs.Add(6.65);

Compter le nombre d'éléments d'un ensemble avec la propriété count

Dans l'exemple suivant, on compte le nombre de tarifs de l'ensemble tarifs.

						
4 Console.WriteLine(tarifs.Count);

output

```
3
```

Supprimer un élément 'un ensemble avec la méthode Remove

Dans l'exemple suivant, on supprime le tarif 6.65.

```
						
5 tarifs.Remove(6.65);
```

Boucler sur les éléments d'un ensemble avec l'instruction d'itération foreach

Dans l'exemple suivant, on boucle sur l'ensemble des tarifs et on affiche chaque tarif dans la console.

						
6 foreach (double tarif in tarifs) { Console.WriteLine(tarif); }

output

```
20
12.5
```

Les dictionnaires

Un dictionnaire est une structure de données permettant de stocker des paires clé-valeur.

Création d'un dictionnaire avec l'interface IDictionary et la classe Dictionary

Dans l'exemple suivant, on crée le dictionnaire vide joueurs avec la clé de type string pour le nom du joueur et la valeur de type int pour ses points.

						
1 IDictionary<string, int> joueurs = new Dictionary<string, int>();

Ajouter un élément à un dictionnaire avec la méthode Add

Dans l'exemple suivant, on ajoute les joueurs Bob et Lisa au dictionnaire joueurs.

						
2 joueurs.Add("Bob", 18);
3 joueurs.Add("Lisa", 22);

Accéder à un élément du dictionnaire avec la clé entre crochets

Dans l'exemple suivant, on affiche les points de Bob.

						
4 Console.WriteLine(joueurs["Bob"]);

Modifier la valeur d'un élément du dictionnaire

Dans l'exemple suivant, on modifie les points de Lisa.

```
						
5 joueurs["Lisa"] = 23;
```

Compter le nombre d'éléments d'un dictionnaire avec la propriété count

Dans l'exemple suivant, on compte le nombre de joueurs du dictionnaires joueurs.

						
6 Console.WriteLine(joueurs.Count);

output

```
2
```

Boucler sur les éléments d'un dictionnaire avec l'instruction d'itération foreach et les propriétés Key et Value

Dans l'exemple suivant, on boucle sur l'ensemble des joueurs et on affiche chaque joueur et ses points dans la console.

						
7 foreach (var paire in joueurs){ Console.WriteLine(paire.Key + paire.Value);}

output

```
Bob18
Lisa23
```

Retirer un élément d'un dictionnaire avec la méthode Remove

Dans l'exemple suivant, on retire Bob du dictionnaires joueurs.

```
						
8 joueurs.remove("Bob");
```

Les enumérations

Une énumération est une structure de données permettant de définir un ensemble de constantes nommées, utilisée par exemple avec l'instruction switch.

Création d'une énumération avec le mot clé enum

Dans l'exemple suivant, on crée l'énumération Saison.

						
1 enum Saison { printemps, été,  automne, hiver }

Accéder à un élément d'une énumération avec sa valeur.

Dans l'exemple suivant, on affiche les points de Bob.

						
2 Saison saison = Saison.printemps;
3 Console.WriteLine(saison);

output

```
printemps
```

Les classes

En programmation orientée objet (POO), une classe est un modèle pour créer des objets.

Dans ce chapitre, nous allons voir la déclaration, l'instanciation, les attributs et les méthodes.

La déclaration

Pour déclarer une classe, on écrit class NomClasse.
On utilise la convention de nommage PascalCase avec la première lettre de chaque mot en majuscule.

Dans l'exemple suivant, on déclare la classe Voiture.

```
						
1 class Voiture
2 {
3 }
```

Les attributs

Un attribut est un champs propriété associé à la classe.

On ajoute les attributs couleur et annee à la classe Voiture.

						
1 class Voiture
2 {
3     public string couleur;
4     public int annee;
5 }

Les méthodes

Une méthode est une fonction de classe.
Une méthode d'instance est utilisée avec une instance de classe. On utilise la convention de nommage PascalCase.

On ajoute la méthode ShowDetails à la classe Voiture.

						
1 class Voiture
2 {
3     public string couleur;
4     public int annee;
5     public void ShowDetails()
6     {
7         Console.WriteLine(annee + " " + couleur)
8     {
5 }

Les paramètres et les sorties

Les entrées de la méthode appelées paramètres sont définies à l'intérieur des parenthèses avec leurs types et leurs noms.
Les valeurs des paramètres appelées arguments sont passées entre parenthèses lors de l'appel de la méthode.
Les sorties sont renvoyées grâce à l'instruction return.

Dans l'exemple suivant, la méthode Sommer prend a et b en entrées et renvoie la somme en sortie.


1 static int Sommer(int a, int b)
2 {
3     int somme = a + b;				
4     return somme;
5 }
6 int resultat = Sommer(1, 2);
7 Console.WriteLine(resultat)

output

```
3
```

Les méthodes statiques

Une méthode statique est appelée sur une classe plutôt que sur une instance de classe.

Dans l'exemple suivant, la méthode Sommer est une méthode statique.


1 Calcul.Sommer(1, 2);
2 public class Calcul
3 {
4     public static void Sommer(int a, int b)
5     {	
6         Console.WriteLine(a + b);
7     }
8 }

output

```
3
```

L'instanciation

L'instanciation permet de créer les objets qui sont des instances de classe.

Dans l'exemple suivant, le mot-clé new permet de créer la nouvelle instance voiture1 de la classe Voiture.

						
1 Voiture voiture1 = new Voiture();

L'affectation

L'affectation permet de d'affecter une valeur à une propriété.

Pour affecter une valeur à l'attribut couleur de l'instance voiture1, on écrit voiture1.couleur = maCouleur.

						
2 voiture1.couleur = "blue";
3 voiture1.annee = 2010;

Utilisation propriété et méthode

Une fois instanciée, on peut utiliser les propriétés et les méthodes d'instance de classe.

Pour utiliser une propriété on écrit voiture1.couleur.
Pour appeler la méthode ShowDetails, on écrit voiture1.ShowDetails().

				
4 Console.WriteLine(voiture1.couleur);
5 voiture1.ShowDetails();

output

```
blue
2010 blue 
```

Voici le code complet de notre exemple.

⚠️ La partie définition de la classe se place après l'instanciation.


1 Voiture voiture1 = new Voiture();			
2 voiture1.couleur = "blue";
3 voiture1.annee = 2010;
4 Console.WriteLine(voiture1.couleur);
5 voiture1.ShowDetails();
6 class Voiture
7 {
8     public string couleur;
9     public int annee;
10     public void ShowDetails()
11     {
12         Console.WriteLine(annee + " " + couleur)
13     {
14 }

Les classes statiques

Une classe statique est une classe qui ne peut pas être instanciée.

Elle est déclarée avec le mot-clé static.
Elle contient souvent des utilitaires, comme par exemple la classe Math.
Une classe utilitaire contient souvent des méthodes statiques, appelées directement sur la classe, comme dans l'exemple suivant.


1 Console.WriteLine(Math.PI);
2 Console.WriteLine(Math.Abs(-1));

output

```
3.14159265358979
1
```

Les constructeurs

Un constructeur est une méthode spéciale qui port le même nom que la classe et qui permet d'initialiser et d'utiliser les attributs.
Il existe les constructeurs par défaut et les constructeurs paramétrés.

Les constructeurs pas défaut

Un constructeur par défaut permet de définir une valeur d'attribut par défaut. Il n'a donc pas de paramètres.
S'il n'est pas défini explicitement dans la classe, il est automatiquement fourni par le compilateur.
Reprenons l'exemple de la classe Voiture en utilisant un constructeur, avec une chaine vide comme valeur par défaut pour l'attribut couleur et 2000 comme valeur par défaut pour l'attribut année.


1 Voiture voiture1 = new Voiture()
2 Console.WriteLine("Ma voiture de couleur " + voiture1.couleur + " a été fabriquée en " + voiture1.annee);
3 public class Voiture
4 {
5     public string couleur;
6     public int annee;
7     public Voiture()
8     {
9         couleur = "";
10         annee = 2000;
11     }
12 }

output


Ma voiture de couleur  a été fabriquée en 2000

Les constructeurs paramétrés

Un constructeur paramétré a des paramètres permettant d'initialiser ses attributs grâce au mot clé this faisant référence à l’instance actuelle de la classe.
Reprenons l'exemple de la classe Voiture en utilisant cette fois un constructeur paramétré.
Lors de l'instanciation, il faut ajouter les arguments pour les paramètres couleur et annee.


1 Voiture voiture1 = new Voiture("rouge", 2000);
2 Console.WriteLine("Ma voiture couleur " + voiture1.couleur + " a été fabriquée en " + voiture1.annee);
3 public class Voiture
4 {
5     public string couleur;
6     public int annee;
7     public Voiture(string couleur, int annee)
8     {
9         this.couleur = couleur;
10         this.annee = annee;
11     }
12 }

output


Ma voiture couleur rouge a été fabriquée en 2000

Les propriétés getter et setter

La propriété getter est une méthode qui permet de récupérer la valeur actuelle d'un champ privé grâce à l'accesseur get.
La propriété setter est une méthode qui permet de modifier la valeur actuelle d'un champ privé grâce à l'accesseur set et au mot clé value.

Les attribus et couleur de ma classe Voiture sont maintenant privés. On crée donc les propriétés Couleurs et Annee pour les utiliser.


1 public class Voiture
2 {
3     private string couleur;
4     private int annee;
5     public Voiture(string couleur, int annee)
6     {
7         this.Couleur = couleur;
8         this.Annee = annee;
9     }
10     public string Couleur
11     {
12         get { return couleur; }
13         set { couleur = value; }
14     }
15     public int Annee
16     {
17         get { return annee; }
18         set { annee = value; }
19     }
20 }

Les conditions

Une condition permet d'exécuter un bloc de code si le résultat du test conditionnel est vrai.

Dans ce chapitre, nous allons voir les conditions if else, les opérateurs de comparaisons et l'instruction switch.

La structure conditionnelle if else

Elle s'écrit if (test) { instructions } else if (test) { instructions } else { instructions }

Dans l'exemple suivant, on fait des tests sur la moyenne d'un élève pour lui donner son appréciation.

						
1 int moyenne = 13;
2 if ( moyenne >= 16 ) { Console.WriteLine("Félicitations"); }
3 else if (moyenne >= 12) { Console.WriteLine("Encouragements"); }
4 else { Console.WriteLine("avertissement"); }

output

```
Encouragements
```

Les opérateurs de comparaisons et les opérateurs logiques

Ils permettent de faire les tests conditionnels.

Le tableau suivant présente les opérateurs de comparaisons.

Opérateur	Signification
==	Egal
!=	Différent
<	Inférieur
<=	Inférieur égal
>	Supérieur
>=	Supérieur égal

Les opérateurs logiques permettent de combiner les tests logiques.
Le tableau suivant présente les opérateurs logiques.

Opérateur	Description	Exemple	Résultat
&&	ET logique	true && false	false
\|\|	OU logique	true \|\| false	true
!	NON logique	!true	false

L'instruction switch

L'instruction switch permet de tester une expression parmis plusieurs choix.
Elle s'écrit switch (expression){case valeur1: instructions; break; case valeurn: instructions; break; default: instructions; break;}

Dans l'exemple suivant, on teste le classement d'un athlète parmis plusieurs choix afin de lui donner la bonne médaille.

						
1 int classement = 2;
2 switch (classement){
3 case 1: Console.WriteLine("Médaille d'or"); break; 
4 case 2: Console.WriteLine("Médaille d'argent"); break;
5 case 3: Console.WriteLine("Médaille de bronze"); break;
6 default: Console.WriteLine("Pas de médaille"); break;}

output

```
Médaille d'argent
```

L'instruction switch peut s'utiliser avec l'énumération.

Dans l'exemple suivant, on teste si la saison actuelle est l'été.

						
1 Saison saison = Saison.printemps;
2 switch (saison){
3 case Saison.printemps: Console.WriteLine("C'est la saison des amours"); break;
4 default: Console.WriteLine("C'est une autre saison"); break;}

output

```
C'est la saison des amours
```

Les boucles

Une boucle permet d'exécuter un bloc de code plusieurs fois.

Dans ce chapitre, nous allons voir les boucles for, while et do while.

La boucle for

Elle est utilisée pour un nombre connu d'itérations.
Elle s'écrit for (valeurDébut; valeurFin; incrément) { instructions }

Dans l'exemple suivant, on répère trois fois le cri de joie hip hip hip hourra!.

						
1 for (int i = 0; i < 3; i++)
2 {
3     Console.WriteLine("hip hip hip hourra!");
4 }

output


hip hip hip hourra!
hip hip hip hourra!
hip hip hip hourra!

La boucle while

Elle est utilisée tant qu'une condition est vraie.
Elle s'écrit while (test conditionnel) { instructions }

Dans l'exemple suivant, on écrit One more time tant que j inférieur à 3.


1 int j = 0;
2 while (j < 3)
3 {
4     Console.WriteLine("One more time");
5     j++;
6 }

output


One more time
One more time
One more time

La boucle do while

Le bloc d'instructions est effectué une première fois puis répété tant qu'une condition est vraie.
Elle s'écrit do { instructions } while (test conditionnel)

Dans l'exemple suivant, on écrit Around The World une première fois qu'on répètre tant que k inférieur à 3.


1 int k = 0;
2 do
3 {
4     Console.WriteLine("Around The World");
5     j++;
6 } while (k < 3);

output


Around The World
Around The World
Around The World

L'instruction continue

Elle permet de passer l'instruction en cours à une certaine condition.

Reprenons l'exemple de la boucle for, en ajoutant l'instruction continue avec une condition sur i = 1.

						
1 for (int i = 0; i < 3; i++)
2 {
3     if (i == 1) { continue; }	
4     Console.WriteLine("hip hip hip hourra!");
5 }

output


hip hip hip hourra!
hip hip hip hourra!

L'instruction break

Elle permet d'interrompre la boucle en cours à une certaine condition.

Reprenons l'exemple de la boucle for, en ajoutant l'instruction break avec une condition sur i = i.

						
1 for (int i = 0; i < 3; i++)
2 {
3     if (i == 1) { break; }	
4     Console.WriteLine("hip hip hip hourra!");
5 }

output

```
hip hip hip hourra!
```

Communiquer

Avec un utilisateur, avec un fichier et avec un site web.

Avec un utilisateur

Entrées et sorties utilisateur dans le terminal

Afficher du texte dans la console grâce à la méthode WriteLine de la classe Console

Dans l'exemple suivante, on demande le nom de l'utilisateur.

						
1 Console.WriteLine("Comment t'appelles-tu?");

output

```
Comment t'appelles-tu?
```

Lire du texte saisi par l'utilisateur dans la console grâce à la méthode Readline de la classe Console

L'utilisateur répond, on lit sa réponse et on le salue en retour.

						
2 string nom = Console.ReadLine();
3 Console.WriteLine("Salut Bob");

output

```
Bob
Salut Bob!
```

Avec un fichier

Lire et écrire un fichier texte avec le namespace System.IO.

Lire un fichier texte grâce à la méthode ReadAllText de la classe File

Dans l'exemple suivant, on lit le texte du fichier weather.txt.

using System.IO;
1 using System.IO;
2 todayWeather = File.ReadAllText("C:/Users/username/weather.txt");
3 Console.WriteLine(todayWeather);

output

```
Il fait beau!
```

Ecrire un fichier texte grâce à la méthode WriteAllText de la classe File

Dans l'exemple suivant, on écrit le texte dans le fichier test.txt.

						
1 File.WriteAllText("C:/Users/username/test.txt", "Ceci est un fichier texte de test.");

output

```
Bob
Salut Bob
```

Remarque: Il est conseillé d'utiliser ces 2 méthodes avec les instructions try et catch que nous verrons plus tard.

Avec un site web

Requêtes réponses d'un site web avec son URL

Vérification d'un URL avec la méthode IsWellFormedUriString de la classe Uri

Dans l'exemple suivant, on teste l'URL http://nicot3m.free.fr.

						
1 if (Uri.IsWellFormedUriString(url, UriKind.Absolute))
2 {Console.WriteLine("url correct");}
3 else
4 {Console.WriteLine("url incorect");}

output

```
url correct
```

Récupérer le contenu d'un site web avec la méthode GetStringAsync de la classe HttpClient.

Dans l'exemple suivant, on récupère le contenu de l'URL http://nicot3m.free.fr.

						
1 try { Console.WriteLine(new HttpClient().GetStringAsync(url).Result); }
2 {catch (Exception ex) { Console.WriteLine("Une erreur s'est produite : " + ex.Message);}

output

```
... <itle>nicot3m</title> ...
```

Les programmes

Un programme est un ensemble d'instructions écrites dans le langage de programmation, dans ce cours c'est le C#.

Dans ce chapitre, nous allons voir la structure d'un programme, la structure du dossier le contenant et les étapes de son exécution.

La structure d'un programme

Un programme C# est généralement structuré en classes.

Dans l'exemple suivant, on crée la classe Program contenant la méthode Main.

						
1 using System;
2
3 namespace Programme
4 {
5     internal class Program
6     {
7         static void Main(string[] args)
8         {
9             Console.WriteLine("Hello World!");
10            Console.ReadKey(true);
11        }
12     }
13 }

output

```
Hello World!
```

Voici les explications sur la structure du programme.

La directive using spécifie l'espace de noms System pour que le programme puisse utiliser les fonctionnalités de base du système.
Le namespace Programme est l'espace de noms de notre programme.
La classe Program contient notre programme.
La méthode Main est la fonction principale exécutée en premier. Elle appelle les autres classes et elle doit être courte.

La structure du dossier racine

Le dossier racine comprend l'ensemble du code. Nommons le Programme.

Il contient un autre dossier Programme correspondant au namespace Programme.
Ce dernier dossier contient le fichier Program.cs, du nom de la classe contenant le Main.

L'exécution du programme

Compilation et exécution

Le code écrit en C# est convertit en langage intermédiaire bytecode CIL (Common Intermediate Language).
Il est ensuite assemblé en code machine natif par le compilateur JIT (Just In Time) du runtime.
Il est enfin exécuté par le CPU.

Les exceptions

Une exception est une erreur lors de l'exécution du programme qui se gère grâce aux instructions try et catch

Si l'on veut lever une exception non spécifique on peut utiliser Exception avec e comme message d'erreur.
Dans l'exemple suivant, on lève l'exception DivideByZeroException si le diviseur est nul.

						
1 int diviseur = 0;
2 try
3 {
4     int quotient = 84 / diviseur;
5     Console.WriteLine("quotient = " + quotient);
6 }
7 catch (DivideByZeroException e)
8 {
9     Console.WriteLine("division par zéro interdite");
10 }

output

```
division par zéro interdite
```

Sortir

La méthode Exit permet de sortir du programme en renvoyant un code de sortie.

Dans l'exemple suivant, la méthode Exit renvoie le code sortie -1 pour indiquer qu'il y a eu un problème.

```
						
1 Environment.Exit(-1);
```

La Recursivité

La Recursivité est une méthode qui s'appelle elle-même.

Dans l'exemple suivant, on utilise la récursivité pour calculer la factorielle de 4.

						
1 Console.Write(Recursivite.Factorielle(4));
2 public class Recursivite
3 {
4     public static int Factorielle(int n)
5     {
6         if (n==0) { return 1; }
7         else { return n * Factorielle(n - 1);}
8     }
9 }

output

```
24
```

Le langage C Sharp

Commencer

Environnement

Mon premier programme

Les commentaires

Les variables

Déclaration

Les types de variables

Les nombres

Le texte

Les booléens

La portée des variables

Les variables de type valeur ou référence

Les structures de données

Les tableaux

Les matrices

Les listes

Les ensembles

Les dictionnaires

Les enumérations

Les classes

La déclaration

Les attributs

Les méthodes

L'instanciation

L'affectation

Utilisation propriété et méthode

Les classes statiques

Les constructeurs

Les propriétés getter et setter

Les conditions

La structure conditionnelle if else

Les opérateurs de comparaisons et les opérateurs logiques

L'instruction switch

Les boucles

La boucle for

La boucle while

La boucle do while

L'instruction continue

L'instruction break

Communiquer

Avec un utilisateur

Avec un fichier

Avec un site web

Les programmes

La structure d'un programme

La structure du dossier racine

L'exécution du programme

Les exceptions

Sortir

La Recursivité