Le langage C# de Microsoft .

Introduction
Le C# (cé Sharp) et le .NET ont été par Anders Hejlsberg (le
créateur du langage Delphi ) alors employé chez Microsoft.
2001 : création du C#
2002: naissance du Framework .Net: 1.0
Les autres versions du .NET: 2.0, 3.0, 3.5, 4.0, 4.5, 4,8.
Le C# est considéré comme le langage phare de Microsoft

Utilisation du C#
application de bureau, Développement
mobile (Windows mobile et Android ),
web, jeux vidéo (unity 3D)…

Les fichiers sources
• Un fichier source C# porte l'extension ".cs". Il s'agit d'un fichier texte.
• Le programme compilé porte l'extension ".exe".
• Une bibliothèque rassemble des classes et porte l'extension ".dll". Elle
peut être utilisée par un programme ou une autre bibliothèque

La compilation
• Un compilateur C# permet la traduction du programme source en
instructions .Net.
• Contrairement à d'autres compilateurs, ces instructions sont
produites pour un processeur virtuel et ne sont donc pas directement
interprétées par le processeur, mais interprétés par le moteur .Net.
• Sous Windows, le compilateur produit un exécutable appelant
l'interpréteur .Net.
• Sous Linux, le programme produit n'est pas directement exécutable
et doit être lancé en argument de l'interpréteur mono.

Un premier programme
• « Hello world » Cet exemple typique de programmation est censé montrer la syntaxe du
langage.
Le fichier source Enregistrez le listing suivant dans un document texte, intitulé par exemple «
helloworld.cs » :
using System;
public class HelloWorld {
public static void Main()
{
Console.WriteLine("Hello world !");
Console.ReadLine();
}
}

Test
• Compilez-le, puis lancer l'exécutable produit. Le programme doit
afficher :
• Hello world !

Détails
• Voici le détail ligne par ligne du fichier source, certains concepts étant expliqués dans
les cours suivants :
using System; le fichier source utilise un espace de noms (bibliothèque) dans lequel
plusieurs classes utiles sont définies
public class HelloWorld { Déclaration d'une classe nommée "HelloWorld".
public static void Main() { Déclaration d'une méthode statique nommée "Main" dans
la classe HelloWorld. Cette méthode est celle qui est appelée au démarrage du
programme.
Console.WriteLine("Hello world !"); Affichage de la ligne "Hello world !" sur la
console. Console désignant la console, appartient à l'espace de nom System.
Console.ReadLine(); Attendre que la touche entrée soit frappée avant de poursuivre.

• } : Fin de la méthode Main.
• } : Fin de la classe HelloWorld.
• Hello world en bibliothèque : Le programme de cet exemple a le
même but que le précédent : afficher le message "Hello world !" sur
la console. Cette version utilisera une seconde classe compilée en
bibliothèque.

Les fichiers sources
• Enregistrez ce premier listing dans l’environnement dotnet , intitulé par
exemple « helloworld.cs » :
using System;
public class HelloWorld {
public static void Afficher() {
Console.WriteLine("Hello world !");
Console.ReadLine();
}
}

public class PremierProg {
public static void Main() {
// appel à la méthode statique Afficher() de la classe HelloWorld
HelloWorld.Afficher();
}
}

Bloc de commentaire
• Un bloc de commentaire est délimité par les signes slash-étoile /* et
étoile-slash */ comme en Java et en C++. Exemple :
/*
Un commentaire explicatif
sur plusieurs lignes...
*/

Commentaire de fin de ligne
• Un commentaire de fin de ligne débute par un double slash // et se
termine au prochain retour à la ligne. Exemple :
x++; // augmenter x de 1

Commentaire de documentation
• Le langage C# utilise une forme spéciale des commentaires pour
documenter les classes. Ces commentaires commencent par un triple
slash /// et se terminent au prochain retour à la ligne. Alternativement, ils
peuvent être encadrés par /** et */.
• Exemple :
/// Une classe pour démontrer
/// les commentaires de documentation
public class Exemple {
...
}

Les variables
• Une variable réserve une place en mémoire pour stocker des
données : résultats d'expressions, données lues depuis un
fichier, ... Elle est associée à un nom.
• Déclaration : Une variable possède un nom et un type. Ce type
détermine ce que peut stocker la variable : un nombre, une
chaîne de caractère, un objet d'une classe particulière ...
• La syntaxe est la suivante :
• type nom [ = expression ] ;

Les variables
• Exemples :
double prix_unitaire;
int quantite = 50;
string article = "Pommes";
bool remise = false;

Les variables
• initialiser une variable à la déclaration n'est pas obligatoire. Dans ce
cas, elle possède la valeur par défaut correspondant au type :
• la valeur par défaut des types numériques et caractères (char) est
zéro (0),
• la valeur par défaut du type booléen (bool) est false,
• la valeur par défaut des types références (objet, chaîne de caractère,
tableaux) est null,
• la valeur par défaut des types énumérés (enum) est celle qui
correspond au type sous-jacent (int par défaut).

• Il est possible de regrouper la déclaration de plusieurs variables du
même type en utilisant une virgule pour séparer les différentes
variables.
• Exemple :
int quantite = 50, nombre, quantite_en_stock = 100 ;
Ou en plaçant une variable par ligne pour plus de clarté :
int quantite = 50,
nombre,
quantite_en_stock = 100 ;

Utilisation :
• Une variable est utilisée pour stocker des résultats intermédiaires, des
données qui serviront ultérieurement. La valeur d'une variable peut
être modifiée autant de fois que nécessaire.
• Exemple :
prix_unitaire = 1.50;
if (remise=true) prix_unitaire = prix_unitaire - 0.20;
double prix_total = prix_unitaire * quantite ;

• Durée de vie d'une variable: La durée de vie d'une variable est la
période durant laquelle une variable existe, c'est à dire conserve son
emplacement en mémoire et durant laquelle elle peut donc stocker
des données.
• Variable en lecture seule :Une variable peut être déclarée en lecture
seule en utilisant le mot-clé readonly.
• Exemple :
readonly double taux_tva = 19.6;

Les constantes
• Une constante nommée est associée à une valeur pour toute la durée
de l'application. Sa valeur ne peut changer.
• La syntaxe est similaire à celle de la déclaration d'une variable,
excepté que le mot clé const précède la déclaration, et que
l'initialisation à la déclaration est obligatoire :
• const type nom = expression ;
• Exemple :
• const double prix_unitaire_unique = 1.50 ;
• const double taux_euro_en_dzd = 215.50;

Les types de base et les déclarations
• En C#, il existe deux catégories de type :
• Les types valeurs qui stockent directement la valeur des données (un
entier, une chaîne de caractères, une structure),
• Les types références qui stockent une référence vers la valeur des
données (un tableau, un objet, une interface).
• Un type de base est un type simple valeur.

Les opérateurs
• Les opérateurs arithmétiques:
Parmi les opérateurs arithmétiques, il y a les quatre opérateurs de
base classiques :
• l'addition : 5 + 2 (7)
• la soustraction : 7 - 5 (2)
• la multiplication : 3 * 4 (12)
• la division : 12 / 4 (3)

• Cependant, la division sur deux nombres entiers produit un nombre
entier.
• Le reste de cette division est donné par l'opérateur modulo : 13 % 3
(1, car 13 = 3*4 + 1)
• La division donnera un nombre à virgule flottante si au moins l'un des
deux opérandes est de ce type : 12.0 / 5 donnera 2.4.

• Les opérateurs de comparaison: Chaque opérateur de comparaison
retourne un booléen (true ou false) déterminant si la condition est
vraie ou fausse :
• L'opérateur d'égalité : a == b
• L'opérateur d'inégalité : a != b
• L'opérateur inférieur à : a < b
• L'opérateur supérieur à : a > b
• L'opérateur inférieur ou égal à : a <= b
• L'opérateur supérieur ou égal à : a >= b

• Les opérateurs booléens:
Une expression booléenne sont des conditions qui peuvent être
combinées avec les opérateurs suivants :
• L'opérateur non retourne le contraire de l'opérande (vrai pour faux,
et faux pour vrai). Exemple : !(a==5)
• L'opérateur et ne retourne vrai que si les deux opérandes sont vrais.
Exemple : (a==5) && (b==0)
• L'opérateur ou retourne vrai si l'un des deux opérandes est vrai.
Exemple : (a==5) || (b==0)

• L'opérateur ou exclusif retourne vrai si un seul des deux opérandes
est vrai, c'est à dire qu'il retourne vrai pour les couples d'opérandes
(vrai, faux) et (faux, vrai). Comme dans de nombreux langages, il
n'existe pas d'opérateur ou-exclusif spécifique. Mais on peut utiliser
l'opérateur de comparaison différent pour comparer les valeurs
booléennes (false/true). Exemple : (a==5) != (b==0)

• Les opérateurs de manipulation des bits: Les exemples montrent la
représentation binaire des opérandes de type octet (byte), donc sur 8
bits. Les opérateurs suivants manipulent les bits :
• L'opérateur non retourne l'inverse des bits de l'opérande (0 pour 1, et
1 pour 0). Exemple : ~ 0x93
~ 1001 0011 (0x93) = 0110 1100 (0x6C)
• L'opérateur et ne retourne que les bits à 1 communs aux deux
opérandes. Exemple : 0x93 & 0x36
1001 0011 (0x93) & 0011 0110 (0x36) = 0001 0010 (0x12)

• L'opérateur ou retourne les bits à 0 communs aux deux opérandes.
Exemple : 0x93 | 0x36
1001 0011 (0x93) | 0011 0110 (0x36) = 1011 0111 (0xB7)
Les parenthèses:
Les parenthèses permettent de convertir tout type en un autre. La
conversion d'objet d'une classe en une autre n'est possible que si le
type réel de l'expression convertie est une sous-classe du type
spécifié, ou implémente l'interface spécifiée. Dans le cas contraire,
l'opérateur lance une exception. La syntaxe est la suivante :

(nouveau_type)expression .
Exemple : int longueur = (int)( 10.2 * 3.1415 );
• L'affectation avec opération:
• Un tel opérateur effectue une opération utilisant la valeur actuelle d'une variable et
affecte le résultat à cette même variable.
variable opérateur = expression
Cette syntaxe est l'équivalent de la suivante :
variable = variable opérateur expression
Ces opérateurs d'affectation sont les suivants :

Opérateur Exemple Équivalent
+= a+=5 a=a+5
-= a-=5 a=a-5
*= A*=5 a=a*5
/= a/=5 a=a/5
%= A%=5 a=a%5
&= a&=5 a=a&5
^= a^=5 a=a^5
|= a|=5 a=a|5

Structures de contrôle
• Le langage C# est un langage de programmation structuré. La
structure d'un programme définit l'ordre d'exécution des
instructions : condition, boucles, ...

Condition
• Une instruction peut s'exécuter lorsqu'une condition est vraie. La
syntaxe est la suivante :
if (expression) instruction
Expression: définit la condition et doit être du type bool, c'est à dire
qu'elle ne peut valoir que true (vrai) ou false (faux).
L'instruction n'est exécutée que si la condition est vraie (true).
Exemple : if (a==10) Console.WriteLine("a vaut 10");

• Plusieurs instructions : Pour exécuter plusieurs instructions si la
condition est vraie, instruction peut être remplacé par un bloc
d'instructions entre accolades :
• {
instruction1
Instruction2
...
}

• Exemple :
if (a==10) {
Console.WriteLine("a vaut 10"); a=9;
Console.WriteLine("désormais a vaut 9");
}
• Sinon...
Il est possible d'exécuter des instructions quand une condition est
vraie, et d'autres instructions quand elle est fausse. La syntaxe est la
suivante :

• if (expression) instruction else instruction
• Exemples : if (a>=10) Console.WriteLine("admis"); else
Console.WriteLine("ajourné");

• Condition multiple :
L'enchaînement des instructions conditionnelles est possible.
• Exemple :
if (a==10)
if (b==11) Console.WriteLine("a vaut 10 et b vaut 11");
else Console.WriteLine("a vaut 10 mais b ne vaut pas 11");
else Console.WriteLine("a ne vaut pas 10");

• Chaque instruction else correspond au if qui le précède, s'il n'a pas déjà de
else. Cependant, pour clarifier le code ou résoudre certains cas ambigus (pas
de else pour le second if, par exemple), il est préférable de mettre des
accolades :
if (a==10)
{
if (b==11) Console.WriteLine("a vaut 10 et b vaut 11");
else Console.WriteLine("a vaut 10 mais b ne vaut pas 11");
}
else Console.WriteLine("a ne vaut pas 10");

• Autre exemple :
if (a==10) Console.WriteLine("a vaut 10");
else if (a==11) Console.WriteLine("a vaut 11");
else Console.WriteLine("a ne vaut ni 10, ni 11");
• Dans cet exemple, chaque instruction if n'est testée que si la précédente
est fausse. Si le nombre de cas est important et que chaque condition
teste une valeur pour la même expression, il est préférable d'utiliser
l'instruction switch.

Où cas peut avoir l'une des deux syntaxes suivantes :
• case constante :
Cas où l'expression vaut la constante spécifiée.
• Default:
Cas où l'expression ne correspond à aucun autre cas (le cas par défaut).
fin du cas :est une instruction spéciale terminant le ou les cas. Hormis les instructions interrompant
le cours de l'exécution, il s'agit en général de l'une des deux instructions suivantes :
• break;
Fin du test, la prochaine instruction exécutée est celle située après l'accolade fermante de switch.
• goto cas;
L'exécution se poursuit au cas indiqué.

• Exemple:
switch(a)
{
case 10 :
Console.WriteLine("a vaut 10");
break;
case 11 :
break;
default :
Console.WriteLine("a ne vaut ni 10, ni 11");
break;
}

• La syntaxe permet de rassembler plusieurs cas ensembles pour exécuter les mêmes instructions :
switch(a)
{
case 2 :
case 3 :
case 5 :
Console.WriteLine("a vaut 2, 3 ou 5");
break;
case 10 :
case 11 :
Console.WriteLine("a vaut 10 ou 11");
break;
default :
Console.WriteLine("a n'est pas dans la liste (2, 3, 5, 10, 11)");
break;
}

• Il est également possible de poursuivre le traitement avec les instructions d'un autre cas :
switch(a)
{
case 10 :
goto case 11;
case 11 :
Console.WriteLine("a vaut "+a);
break;
default :
Console.WriteLine("a ne vaut ni 10, ni 11");
break;
}

Boucles
• Une boucle permet d'exécuter plusieurs fois une ou des instructions
tant qu'une condition est vraie.

Boucle while
• La boucle while est la plus simple : tant que la condition est vraie, elle
exécute l'instruction ou le bloc
d'instructions spécifié.
Sa syntaxe est la suivante :
while ( expression )
instruction_ou_bloc
• Où expression est une expression du type bool, c'est à dire valant true
(vrai) ou false (faux).

• Exemple : calculer les 04 premiers nombres entiers :
int i=0;
int s=0;
While (i<4) {
s= s+i;
i++;
}

Boucle do...while
• La boucle do...while ressemble à la précédente, excepté que la
condition est testée après. C'est à dire que le bloc d'instructions est
toujours exécuté au moins une fois.
do
{
instructions
}
while ( expression );

• Exemple :
i=0;
s=0
do {
s=s+i;
i++;
}
while (i<4);

Boucle for
La boucle for regroupe plusieurs phases de la boucle :
• L'initialisation,
• La condition, tant qu'elle est vraie la boucle continue,
• Les instructions à exécuter,
• L'instruction (ou les instructions) d'incrémentation, exécutée(s) juste
avant de tester à nouveau la condition.

• La syntaxe d'une boucle for est la suivante :
for ( initialisation ; condition ; incrémentation )
Instructions
Exemple :
S=0;
for (i=0; i<4 ;i++)
s=s+i;

Les tableaux
Dès que l'on travaille avec de nombreuses données homogènes ( de même type)
la première structure de base permettant le regroupement de ces données est
le tableau. C# comme tous les langages algorithmiques propose cette
structure au programmeur. Comme pour les string et pour des raisons
d'efficacité dans l'encombrement mémoire, les tableaux sont gérés par C# ,

Les tableaux C# sont indexés uniquement par des entiers (char, int, long,…) et sur un intervalle fixe à partir
de zéro.
Un tableau C# peut avoir de une ou à plusieurs dimensions, nous avons donc les variétés suivantes de
tableaux :
• Tableaux à une dimension
• Tableaux à plusieurs dimensions (matrices,…)

• Chaque dimension d'un tableau en C# est définie par une valeur ou
longueur, qui est un nombre ou une variable N entier (char, int, long,
…) dont la valeur est supérieur ou égal à zéro. Lorsqu'une dimension a
une longueur N, l'indice associé varie dans l'intervalle [ 0 , N – 1 ].

• Tableau uni-dimensionnel:
Ci-dessous un tableau 'tab' à une dimension, de n+1 cellules
numérotées de 0 à n :

• Il n'y a pas de mot clef spécifique pour la classe tableaux, mais
l'opérateur symbolique [ ] indique qu'une variable de type fixé est un
tableau.
• La taille d'un tableau doit obligatoirement avoir été définie avant que
C# accepte que vous l'utilisiez !

• Déclaration d'une variable de tableau, référence seule:
int [ ] table1;
char [ ] table2;
float [ ] table3;
...
string [ ] tableStr;

• Déclaration d'une variable de tableau avec définition explicite de taille :
• int [ ] table1 = new int [5];
char [ ] table2 = new char [12];
float [ ] table3 = new float [8];
...
string [ ] tableStr = new String [9];
• Le mot clef new correspond à la création d'un nouvel objet (un nouveau
tableau) dont la taille est fixée par la valeur indiquée entre les crochets. Ici
4 tableaux sont crées et prêts à être utilisés : table1 contiendra 5 entiers
32 bits, table2 contiendra 12 caractères, table3 contiendra 8 réels en
simple précision et tableStr contiendra 9 chaînes de type string.

• Il existe en C# un attribut de la classe abstraite mère Array, qui
contient la taille d'un tableau uni-dimensionnel, quelque soit son
type, c'est la propriété Length en lecture seule.
• Exemple :
• int [ ] table1 = {17,-9,4,3,57};
int taille;
taille = table1.Length; // taille = 5

• Utiliser un tableau:
Un tableau en C# s'utilise à travers une cellule repérée par un indice obligatoirement de
type entier. Le premier élément d'un tableau est numéroté 0, le dernier Length-1.
Exemple avec un tableau de type int :
int [ ] table1 = new int [5];
// dans une instruction d'affectation:
table1[0] = -458;
table1[4] = 5891;
table1[5] = 72;
// dans une instruction de boucle:
for (int i = 0 ; i<= table1.Length-1; i++)
table1[i] = 3*i-1;

• Même exemple avec un tableau de type char :
char [ ] table2 = new char [7];
table2[0] = '?' ;
table2[4] = 'a' ;
table2[14] = '#' ;
for (int i = 0 ; i<= table2.Length-1; i++)
table2[i] =(char)('a'+i);

Visual Studio
• Visual Studio est un environnement de développement intégré (IDE).
Il est largement utilisé pour les charges de travail .NET et C++, ainsi
que pour de nombreux autres langages et infrastructures. Il dispose
également d’un très vaste écosystème d’extensions, car Visual Studio
existe depuis plus de 20 ans

Visual Studio et VS Code ?
Visual Studio VS Code
Développé au cours des 25 dernières années Lancé en 2015
Complet (prise en charge des principaux langages,
débogage, édition et fonctionnalités de test intégrés)
Léger (l’utilisateur peut acquérir des extensions
pour prendre en charge différents langages et
plateformes)
Code propriétaire (avec quelques composants open
source)
Open source
Gratuit pour les étudiants, les contributeurs open source
et les particuliers
Gratuit pour tout le monde
Place de marché avec des extensions payantes et gratuites Écosystème de développement d’extensions
florissant avec des extensions OSS et propriétaires

• Visual Studio Code est un éditeur de code source léger et très répondu qui a été lancé
en 2015. Il fait partie de la famille des éditeurs Visual Studio.
• Visual Studio est l’environnement de développement entièrement intégré qui est
fourni avec un éditeur et un débogueur de renommée mondiale.
• VS Code est open source et son utilisation est gratuite. Visual Studio n’est pas open
source, mais l’édition Community est gratuite pour les étudiants, les contributeurs open
source et les particuliers.
• VS Code permet le développement open source extrêmement rapide de ses extensions.
• Dans VS Code, vous gérez la plupart des extensions qui fournissent des outils de build et
une prise en charge linguistique à votre éditeur.
• Dans Visual Studio, beaucoup d’autres éléments sont intégrés pour une expérience plus
ciblée et mieux organisée.

les fonctionnalités
• Visual Studio est surtout connu pour la richesse des expériences qu’il
offre aux développeurs dans l’éditeur, le débogueur et de nombreuses
autres fonctionnalités de programmation.
1- Éditeur: L’éditeur Visual Studio dispose d’excellentes fonctions de
saisie semi-automatique de code, de coloration syntaxique, d’info-
bulles et de signalisation d’erreurs et d’avertissements, avec
suggestions de correction du code. Ces éléments vous aident à mieux
comprendre le code que vous écrivez.

2- Débogueur:
Une fois que vous avez écrit du code, vous voulez le voir fonctionner
dans votre application ou votre site web. Le bouton de lecture vert en
haut de Visual Studio peut vous aider à faire cela ; il lance le
débogueur.
Si votre application est un site web, elle démarre un navigateur sur
votre hôte local.

• Personnalisation
Visual Studio est fortement personnalisable, ce qui vous permet
d’utiliser différents thèmes, polices, couleurs et dispositions de
fenêtres. Vous pouvez définir ces préférences dans Outils > Options.

Extensions:
• Visual Studio est fier d’être un écosystème ouvert dans lequel la
communauté est habilitée à créer des outils de développement étonnants.
• Le Visual Studio Marketplace contient des milliers d’extensions avec des
millions de téléchargements. Certaines sont payantes, d’autres gratuites et
même open source.
• Vous pouvez des extensions pour un grand nombre de fonctionnalités, qu’il
s’agisse de remplacer l’arrière-plan de l’éditeur par une image, d’ajouter
encore plus de couleurs à votre éditeur avec des guides d’indentation
colorés ou de tester des frameworks open source créés par la communauté.

• Programmation en binôme avec Live Share:
La programmation en binôme est l’idée de modifier et de déboguer du code en
collaboration avec d’autres personnes. Coder avec des camarades de classe ou des
collègues est un excellent moyen d’échanger des connaissances de codage, de
procéder à des révisions de code, de résoudre des problèmes ou de partager du
code tout en travaillant à distance.
Live Share permet aux utilisateurs de partager un lien et de permettre à d’autres
personnes de rejoindre votre session de programmation.
La génération de build et le débogage se font toujours sur l’ordinateur hôte, mais
l’hôte peut voir les curseurs des modifications dynamiques des invités.
Les invités peuvent voir le code de l’hôte, les valeurs de débogage et la sortie de build,
le tout au sein de leur propre IDE.

• Publication dans le cloud:
Vous pouvez publier votre application directement dans le cloud à l’aide
des outils de gestion de pipeline et de publication intégrés de Visual
Studio. Elle s’intègre à Azure afin que vous puissiez sélectionner et
afficher les ressources cloud directement à partir de l’IDE. Vous
pouvez également sélectionner la façon dont vous souhaitez effectuer
le déploiement.

Test
1. Quelles sont les différences entre Visual Studio et
Visual Studio Code.
2. Quel est l’outil qui me permet de jumeler des
programmes dans Visual Studio ?
3. Citer les différents fonctionnalités de Visual studio.

Le langage C# de Microsoft .

Contenu connexe

Similaire à Le langage C# de Microsoft .

Plus de MohammedSeriari

Dernier

Le langage C# de Microsoft .