Programmation en C#

Introduction

• Le langage C# (C Sharp) est un langage objet créé spécialement

pour le Framework Microsoft .NET (1ère version en 2002).
• Le Framework .NET est un environnement d'exécution (CLR
Common Language Runtime) ainsi qu'une bibliothèque de classes.
• L'environnement d'exécution (CLR) de .NET est une machine
virtuelle comparable à celle de Java.
Les points communs avec le langage C

• Le C# reprend beaucoup d'éléments de syntaxe du langage C :

• Structure des instructions similaire (terminées par ;) :
déclaration de variables, affectation, appels de fonctions,
passage des paramètres, opérations arithmétiques, etc.
• Blocs délimités par { }
• Commentaires // ou /* */
• Structures de contrôle identiques : if/else, while, do/while,
for( ; ; )
• Portée des variables : limitée au bloc de la déclaration
Créer sa première application C#
Exemple

public class Example

{
public static void Main()
{
Console.WriteLine("Hello World!");
Console.Write("Enter your name: ");
String name = Console.ReadLine();
Console.Write("Good day, " + name);
Console.ReadKey();
}
}
La classe Console

• Représente les flux standard d'entrée, de sortie et d'erreur pour

les applications console.
• Console. Write() ou Console.WriteLine() : Pour
afficher des données sur le console.
• ReadLine() : Lit la ligne de caractères suivante du flux d'entrée
standard.
• Console.ReadKey(): Obtient le caractère suivant ou la touche
de fonction sur laquelle l'utilisateur a appuyé. Nous pourrons nous
en servir par exemple pour faire une pause dans notre application
Concaténer des chaînes

• concaténation via l’opérateur +;

Console.Write("Good day, " + name);
• string.Format
Console.Write(string.Format("Good day, {0}", name));
• String Interpolation
Console.Write($"Good day, {name}");
Types primitifs en C#
Types primitifs en C# (1 / 3)

• Un type primitif c'est un type qui ne nécessite pas une

initialisation avant d'être utilisé. Le framework .NET fournit les
types primitifs, et ce quel que soit le langage utilisé (VB.NET, C#,
C++.NET). Voici la liste des types primitifs de .NET :
Types primitifs en C# (2 / 3)

Nom Description
bool Un type qui peut prendre deux valeurs: true ou false (vrai ou faux)
byte Un type qui prend un octet de mémoire. La valeur ne peut être que
positive (ou zéro) et a un maximum de 255.
char Un type codé sur 2 octets, qui prend un caractère Unicode.
decimal Un type codé sur 16 octets qui peut contenir des nombres décimaux
double Deux fois plus petit que decimal (8 octets). Peut contenir des nombres
décimaux.
float Deux fois plus petite que double (4 octets). Peut contenir des nombres
décimaux mais avec une précision moindre que celle d'un double
int Un nombre entier. Peut contenir des valeurs positives ou négatives. Les
int sont codés sur 4 octets. Est équivalent à Int32.
long Deux fois plus grand que int (8 octets). Contient des nombres entiers
positifs ainsi que des entiers négatifs. Est équivalant à Int64.
short Un type signé de 2 octets. Est équivalent à Int16.
Types primitifs en C# (3 / 3)

Nom Description
sbyte Une byte signée. Cela veut dire que le valeur de la variable peut
être positive ou négative.
string Un type d'une taille indéfinie. Il contient une chaîne de caractères
uint Un int non-signée. Cela signifie que la valeur ne peut être que
positive. En revanche, des nombres deux fois plus grand sont
disponibles.

ulong Un long non-signé.

ushort Un short non-signé
Les variables et les constantes
Qu'est-ce qu'une variable ?

• Une variable représente une valeur et un type de champ. Le type

de champ correspond au type de données stockées dans la
variable (numérique, texte, objet…).
• Les données stockées dans une variable peuvent changer, par
contre le nom de celle-ci ne peut pas changer en cours de route.
Déclaration des variables

• Pour utiliser une variable, il faut d'abord la déclarer (la créer) : on

réserve une partie de la mémoire pour cette variable. On spécifie
ce qu'elle représentera (un entier, un caractère, une image, ...)
en indiquant son type.
• La syntaxe est : type nom;
• Exemple :
• int a;
• Assignation d’une valeur :
• a = 12;
Qu'est-ce qu'une constante ?

• Une constante est un autre type de champ. Elle contient une

valeur qui est assignée lors de la compilation de votre code
source. La valeur de la constante ne pourra jamais être modifiée.
Pour déclarer un constant, il faut utiliser le mot clé const, elles
sont utiles pour rendre votre code plus lisible.
• Déclaration d’une constante :
const float PI = 3.14F;
Les opérateurs
Opérateurs mathématiques et logiques

Opérateur But
*, /, % Multiplication, division, module
+, - Addition, soustraction
& AND logique
^ XOR logique
| OR logique
Opérateurs relationnels

Opérateur But
== Vérifie l'égalité.
!= Vérifie l'inégalité.
> Supérieur à.
< Inférieur à.
>= Supérieur ou égal à.
<= Inférieur ou égal à.
Opérateurs conditionnels logiques

Opérateur But
&& AND conditionnel.
|| OR conditionnel.
! NOT conditionnel.
Les structures de contrôle en C#
Structure de choix simple

• La structure if permet de n'exécuter qu'un bloc d'instructions

uniquement si l'expression est vraie. Le mot clé 'if' signifie en
anglais 'si'. Autrement dit, si la condition est vérifiée, on exécute
l'instruction. Dans le cas contraire, l'instruction sera simplement
ignorée ou une autre instruction alternative sera exécutée.
• La clause 'else' qui signifie 'sinon', ajoutée après le bloc
d'instruction de if, permet de définir une série d'instructions qui
seront exécutées si l'expression if testée est fausse.
La syntaxe à utiliser pour l'instruction if est :

if (condition)
{
// Bloc d'instructions si la condition est vraie
}
else
{
// Bloc d'instructions si la condition est fausse
}
Remarques

• La condition est entourée de parenthèses.

• Chaque action est terminée par point-virgule.
• Les accolades ne sont pas terminées par point-virgule.
• Les accolades ne sont nécessaires que s'il y a plus d'une action.
• La clause else peut être absente.
Exemple d'utilisation de l'instruction if :

int age = 20;

if (age >= 18)
{
Console.WriteLine("Vous êtes majeur.");
}
else
{
Console.WriteLine("Vous êtes mineur.");
}
Structure à choix multiple avec switch

• Une instruction switch peut effectuer plusieurs actions selon la

valeur d'une expression donnée. Le code entre l'instruction case et
le mot clé break est exécuté si la condition est remplie.
La syntaxe de SWITCH

switch (expression) {
case v1:
actions1;
break;
case v2:
actions2;
break;
..
default:
actions_sinon;
break;
}
Remarques

• La valeur de l'expression de contrôle du switch peut être un entier, un

caractère, une chaîne de caractères.
• L'expression de contrôle est entourée de parenthèses.
• La clause default peut être absente.
• Les valeurs vi sont des valeurs possibles de l'expression. Si l'expression a
pour valeur vi, les actions derrière la clause case vi sont exécutées.
• L'instruction break fait sortir de la structure de cas.
• Chaque bloc d'instructions lié à une valeur vi doit se terminer par une
instruction de branchement (break, return, ...) sinon le compilateur
signale une erreur.
Structures de répétition
Structures de répétition

• Une boucle permet d'exécuter une ensemble d'instructions jusqu'à

ce qu'une condition définie soit atteinte.
• Il existe plusieurs types de boucles à utiliser en fonction de votre
besoin dans votre programme.
• En C#, on y trouve la plupart des itérations des autres langages
avec en plus l'instruction foreach qui permet de parcourir
facilement l'intégralité d'un tableau ou d'une collection.
Boucle for en C#

• Structure for La syntaxe est la suivante :

for (i = id; i <=5; i = i + ip){
actions;
}
Remarques

• les 3 arguments du for sont à l'intérieur d'une parenthèse et

séparés par des points-virgules.
• chaque action du for est terminée par un point-virgule.
• l'accolade n'est nécessaire que s'il y a plus d'une action.
• l'accolade n'est pas suivie de point-virgule.
Structure foreach

• La syntaxe est la suivante :

foreach (Type variable in collection)
{
instructions;
}
Remarques

• collection est une collection d'objets énumérable. La collection

d'objets énumérable que nous connaissons déjà est le tableau
• Type est le type des objets de la collection. Pour un tableau, ce
serait le type des éléments du tableau
• variable est une variable locale à la boucle qui va prendre
successivement pour valeur, toutes les valeurs de la collection.
Exemple

string[] language = { "Java", "C#", "PHP", "Python" };

foreach (string l in language)
{
Console.WriteLine(l);
}
Structure tant que (while)

• La boucle se répète tant que la condition est vérifiée. La boucle peut ne

jamais être exécutée. Remarques :
• La condition est entourée de parenthèses.
• Chaque action est terminée par point-virgule.
• L'accolade n'est nécessaire que s'il y a plus d'une action.
• L'accolade n'est pas suivie de point-virgule.
• Syntaxe :
while (condition)
{
actions;
}
Structure répéter jusqu'à (do while)

• La boucle se répète jusqu'à ce que la condition devienne fausse. Ici la

boucle est faite au moins une fois.
• La condition est entourée de parenthèses.
• Chaque action est terminée par point-virgule.
• L'accolade n'est nécessaire que s'il y a plus d'une action.
• L'accolade n'est pas suivie de point-virgule.
• La syntaxe est la suivante :
do
{
instructions;
}
Admission à un module

• Soit un module composé de 3 notes (comprises entre

0 et 20). Tout étudiant se trouvant dans au moins
l’un des trois cas suivants sera refusé :
• deux des trois notes sont strictement inférieures à 7,5
• une note est strictement inférieure à 6
• la moyenne des trois notes est strictement inférieure à 10
• Créer une application console en C# qui permet de
saisir les trois notes puis annonce si l’étudiant est
‘admis’ ou ‘refusé’.