---
title: 1. C# Introduction
tags: C#
---
Le langage de programmation **C#** (prononcé **C-sharp** en anglais) a été développé par la société **Microsoft**, et notamment un de ses employés, **Anders Hejlsberg**, pour la plateforme **.NET** (dot NET).
Ce langage est **orienté objet**, avec un **typage fort**. Il est très proche du langage Java.
Il a été approuvé par **l’European Computer Manufacturers Association (ECMA)** et **l’International Standards Organization (ISO)**.
Il est précompilé en **MSIL** (*Microsoft Intermediate Language*), puis exécuté sur une **machine**, ou compilé en code natif à l'exécution. Il dispose d'un ramasse-miettes **(garbage collector)**.
Il utilise l'API .NET en remplacement des MFC (Microsoft foundation class). Il semble être le nouveau langage pour développer des applications Windows, avec Visual Basic et C++.
## Caractéristiques partagées
Le langage C# possède un certain nombre de caractéristiques communes avec d'autres langages de programmation. Il sera donc plus facile de l'apprendre si ces autres langages sont connus.
### Caractéristiques partagées avec le langage Java
• **Syntaxe** : les mots clés communs avec Java s'utilisent dans les mêmes circontances et de la même manière :
*public, private, protected, abstract, class, interface, try, catch, finally, throw, new,return, this, if, while, do, for, foreach, enum... et le mot clé lock est l'équivalent C# du mot cléJava synchronized;*
• **Garbage collector** : les objets qui ne sont plus référencés sont traités
par le ramasse-miettes afin de libérer la mémoire qu'ils occupent ;
• **Références** : les objets sont en fait des types références ;
• **Documentation automatique** : cette caractéristique commune utilise cependant une syntaxe différente dans les 2 langages : le langage Java utilise les commentaires spéciaux */*** **/* au format HTML, avec des tags commençant par le caractère arobase @ ; tandis que le langage C# utilise les commentaires /// au format XML ;
• **Méthodes courantes** : une majeure partie des méthodes de l'API de C# ressemblent à celles de Java, excepté que **leur nom commence par une majuscule** : Main, Equals, ToString, Length, IndexOf, ...
### Caractéristiques partagées avec le langage C++
• surcharge des opérateurs ;
• structures (mot clé struct) ;
• énumérations (mot clé enum) ;
• pointeurs : il est possible, en mode unsafe, d'utiliser des pointeurs au lieu de références.
### Caractéristiques propres au langage C#
• **propriétés** : une propriété est un couple de méthodes (get et set) appelées lorsque celle-ci est lue ou modifiée ;
• **attributs** : un attribut est lié à une déclaration et contient des méta-données sur celle-ci (méthode obsolète, importée d'une DLL, ...) ;
• **delegate** : un delegate est un modèle de méthode, qui lorsqu'il est appelé, appelle toutes les méthodes qui lui ont été associées. Pour faire un parallèle avec le C++, les delegates peuvent être comparés à des pointeurs de fonction. Leur sémantique est toutefois nettement plus riche qu'en C++.
## Histoire du langage C#
https://docs.microsoft.com/fr-fr/dotnet/csharp/whats-new/csharp-version-history
https://fr.acervolima.com/c-historique-des-versions/
https://www.gladir.com/CODER/CSHARP/intro.htm
## Installation de l'enveronnement
https://stacktraceback.com/cours/c-installation-de-lenvironnement/
https://docs.microsoft.com/fr-fr/visualstudio/install/install-visual-studio?view=vs-2022
## Compilation et Execution
http://igm.univ-mlv.fr/~dr/XPOSE2013/Comparaison_JVM_CLR/machinesVirtuelles.html#Csharp
https://perso.esiee.fr/~perretb/I3FM/POO1/dotnet/index.html#roles-du-clr
### processus d'exécution managée
Le processus d'exécution managé inclut les étapes suivantes:
### :small_blue_diamond:Compilation du code source en MSIL
Un fichier source C# porte l'extension **".cs"**. Il s'agit d'un fichier texte lisible par l'être humain.
La compilateur **CSC** traduit ce code source en langage **MSIL** ***(Microsoft Intermediate Language)*** et génère les métadonnées requises.
<br/>
<div style="text-align:center"><img src="https://i.imgur.com/D2oBobg.png" /></div>
<br/><br/>
Il s’agit d’un code intermédiaire entre le code source **(.cs)** et le code natif directement exécutable par le microprocesseur **(langage machine)**.
Ce code intermédiaire est donc indépendant du code de bas niveau qu’est le langage machine, mais il est capable de manipuler ces constructions de haut niveau que sont les objets.
Le programme compilé porte l'extension **".exe"**.
:::info
- **Compilateur pour Windows**
Si le framework Microsoft .NET est installé, le compilateur nommé **csc.exe** doit se situer dans:
*C:\WINDOWS\Microsoft .Net\Framework\vnuméro_de_version_du_framework.*
- **Compilateur pour Linux**
**Mono** est une implémentation libre de la plate-forme de développement Microsoft .NET.
Le compilateur **csc** n'est pas disponible sur toutes les plates-formes ou dans les très anciennes versions de Mono, dans ce cas, il faut utiliser à la place le compilateur est nommé **msc**.
:::
### :small_blue_diamond:Interpretation du MSIL en code natif et Exécution de code
Avant de pouvoir exécuter le langage MSIL, ce dernier devrait être compilé en code natif pour l'architecture de l'ordinateur cible.
**Compilation par le compilateur JIT**
La machine virtuelle nommée **Common Language Runtime** ***(CLR)*** utilise la compilation **"Just In Time"** pendant l'execution.
Au moment de l'exécution de l'application, Le **compilateur JIT** convertit à la demande le langage **MSIL** en **code natif**.
Le code ainsi compilé est gardé en mémoire afin d'être executé plus rapidement lors de la prochaine passe.
Pendant cette compilation, le code est soumis à un processus de vérification qui examine le MSIL et les métadonnées afin de déterminer si le code peut être considéré comme étant de type sécurisé.
<br/>
<div style="text-align:center"><img src="https://i.imgur.com/ZdhBXSj.png" /></div>
<br/><br/>
**Exécution de code**
La **CLR** fournit l'infrastructure qui permet à l'exécution d'avoir lieu et les services pouvant être utilisés pendant l'exécution.
Pendant l'exécution, le code managé bénéficie de services tels que le garbage collector, la sécurité, l'interopérabilité...
### Compilation et exécution en ligne de commande
La compilation et l'exécution peuvent se faire à l'aide d'un environnement graphique (IDE). Il est toutefois utile de connaître la ligne de commande à utiliser.
#### 1. Utiliser les lignes de commandes pour la compilation :
- Ouvrir une fenêtre console,
- Faire du répertoire du programme à compiler ou exécuter le répertoire courant,
- Vérifier que la variable d'environnement PATH contient le chemin vers le compilateur, en tapant le nom du compilateur (csc sous Windows, gmcs sous Linux (Mono)).
Si le compilateur ne se lance pas (programme non trouvé) :
- Vérifier qu'un compilateur C# est installé,
- Vérifier que le chemin complet du répertoire du compilateur est contenu dans la variable d'environnement PATH,
- Essayer de lancer le compilateur en donnant son chemin complet.
Les syntaxes des commandes à utiliser pour les différentes tâches du développement sont résumées dans le tableau suivant :
<table>
<tr><th>Tâche</th><th>Windows</th><th>Linux (Mono)</th></tr>
<tr><td>compiler un programme (.exe)</td><td>csc   fichier.cs</td><td>csc   fichier.cs</td></tr>
<tr><td>compiler une bibliothèque (.dll)</td><td>csc   /t:library   fichier.cs</td><td>csc    -target:library   fichier.cs</td></tr>
<tr><td>utiliser une bibliothèque (.dll)</td><td>csc   /r:biblio.dll  fichier.cs</td><td>csc   -r:biblio.dll   fichier.cs</td></tr>
</table>
Le compilateur peut produire soit directement un exécutable **".exe"**, soit un module (une bibliothèque DLL **".dll"**) utilisable par d'autres programmes.
<br/>
:::info
:bulb: Une bibliothèque rassemble des classes et porte l’extension **“.dll”**. Elle peut être utilisée par un programme ou une autre bibliothèque.
:::
#### 2. Utiliser les lignes de commandes pour l'execution:
Les syntaxes des commandes à utiliser pour lancer l'exécutable produit :
<table>
<tr><th>Tâche</th><th>Windows</th><th>Linux (Mono)</th></tr>
<tr><td>exécuter un programme (.exe)</td><td>nom_prog.exe</td><td>mono   nom_prog.exe</td></tr>
</table>
## Les commentaires
Tout bon programme a des fichiers sources bien commentés pour expliquer comment cela fonctionne et pourquoi certains choix ont été faits.
Ce qui évite une perte de temps lorsque le code source est repris et modifié, soit par un autre développeur, soit par l'auteur qui ne se souvient pas forcément de son projet s'il n'y a pas touché depuis longtemps
:::warning
**Les commentaires ne sont pas pris en compte par le compilateur**
:::
### :small_blue_diamond: Commentaire de fin de ligne
Un commentaire de ligne débute par un double slash **//** et se termine au prochain retour à la ligne.
Exemple :
```csharp
// augmenter x de 1
x++;
```
### :small_blue_diamond:Bloc de commentaire
Un bloc de commentaire est délimité par les signes slash-étoile /* et étoile-slash */ comme en Java et en C++ pour commenter plusieurs lignes
Exemple :
```csharp
// augmenter x de 1
x++;
```
Les blocs ne peuvent être imbriqués car dès que le compilateur trouve **/***, il recherche la première occurrence **\*/** terminant le commentaire.
### :small_blue_diamond: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 **\*/**.
Le contenu de ces commentaires est au format XML. Il est possible d'utiliser plusieurs lignes. Cette documentation se rapporte toujours à un des éléments de la déclaration qui suit.
Exemple :
```csharp
/// <summary>
/// Une classe pour démontrer
/// les commentaires de documentation
/// </summary>
public class Exemple
{
...
}
```
## Documentaion automatique
Pour qu’il y ait génération automatique de commentaires, il faut, en mode console, compiler le
programme par :
```sh
csc /doc:Example.xml Example.cs
```
https://docs.microsoft.com/fr-fr/visualstudio/ide/reference/generate-xml-documentation-comments?view=vs-2022
https://www.jmdoudoux.fr/microsoft/doctechcsharp/doctechcsharp.htm
https://www.youtube.com/watch?v=ePZakZnBSEE
https://cdiese.fr/documentation-du-code-c-en-1-min/#:~:text=Pour%20g%C3%A9n%C3%A9rer%20la%20documentation%20%C3%A0,cocher%20%E2%80%9CXML%20documentation%20file%E2%80%9D.
https://www.youtube.com/watch?v=uHUkndqnHAg
Le langage C# permet de documenter les classes d'une application en utilisant des commentaires spéciaux juste avant la déclaration de l'élément concerné (espace de noms, classe, interface, méthode, propriété, attribut).
```csharp
using System;
public class HelloWorld
{
public static void Main()
{
Console.WriteLine("Hello world !");
Console.ReadLine();
}
}
```
```sh
npx run docs:generate --template=winter --description="Sparkling and frozen"
--elements="snow,frost,ice" --snowflakes=20
```
### Créer un projet avec la CMD
https://www.youtube.com/watch?v=uHUkndqnHAg&list=PLrSOXFDHBtfGBHAMEg9Om9nF_7R7h5mO7
Tapper la commande suivante dans la console windows
```sh
dotnet new console -o FirstApp
```
Dans le projet créer il ya deux fichier
1. **FirstApp.csproj**:
c'est un fichier xml qui contient des propriétés du projet
```xml
<Project Sdk="Microsoft.NET.Sdk">
```
le SDK utilisé pour le projet
```xml
<OutputType>Exe</OutputType>
```
le type de l'executable qui sera produit par la suite
```xml
<TargetFramework>net6.0</TargetFramework>
```
la cible ou le framework utilisé dans le projet. c'est dans cet endroit qu'on spécifie le framework avec le quel on travaille pour pouvoir compiler.
2. **Program.cs**:
c'est le fichier source de notre rogramme.
```csharp
using System;
```
on n'inclue dans notre programme l'ensemble des classes et d'outil qui vont nous servire dans la programmation c# grace au mot clé **using**.
```csharp
class Program
{
...
}
```
c'est classe C#.
:::info
le nom du fichier n'est pas obligatoirement le nom de la classe contrairement à JAVA
:::
```csharp
public static void Main(string[] args)
{
}
```
c'est une methode de la classe Program. Elle joue le rôle du point d'entrée de mon programme. Quand on execute un programme, il va obligatoirement rechercher cette methode pour commencer l'execution.
:::success
Elle doit obligatoirement s'appeler **Main**
:::
Cette methode contient un ensemble d'instructions.
:::success
Une instrution est une action à faire executer au programme. Elle doit se terminer par **;**
:::
```csharp
Console.WriteLine("Hello Word!");
```
On appelle la methode **WriteLine** (écrire sur une ligne) de la classe **Console** qui se trouve dans le name space **System**. Afin d'afficher le message dans la console.
### Compiler un programme avec dotnet
pour compiler un programme avec dotnet:
```sh
dotnet build
```
Le dossier bin est génégé. dans son sous-dossier debug, on trouve deux fichiers interessant:
- **FirstApp.exe**: le fichier MSIL dans fichier source
- **FristApp.dll**: la bilbioltheque de notre fichier source
### Executer un programme avec dotnet
la commande:
```sh
dotnet run
```
va compiler (***dotnet build***) et executer le programme
### Déployer un programme avec dotnet
la commande:
```sh
dotnet publish
```
Permet de créer une version de deploiement de notre apllication qui est le dossier **publish** dans **\bin\Debug\net6.0\publish**
Sign in with Wallet
Connect another wallet