Pour compiler le C# en ligne : https://dotnetfiddle.net/
---
## Les types variables en C#
1- Les *types valeur*
2- Les *type référence*
---
### Types simples
- sbyte, short, int, long
- byte, ushort, uint, ulong
- char
- float, double, decimal
- bool
---
### Enum
```csharp
enum Color{
Green,
Red,
Black
}
...
Color c = Color.Green
```
---
### Struct
Type défini par l'utilisateur
```csharp
public struct Point {
public double x;
public double y;
}
```
---
### Tuple
Structure de données utilisée pour stocker une collection d'éléments
```csharp
(int, int) point = (0.5, 50)
Consle.WriteLine(point.Item2)
```
---
## Types référence
### Les classes
- Classe de base de tous les types : ``object``
- Classe représetant une chaine de caractères : ``string``
```csharp
string message = "Bonjour";
```
- l'opérateur ``+`` permet de concaténer deux string
```csharp
string name = "Azzeddine"
string message = "Bonjour" + " " + name;
```
- l'opérateur ``[]`` permet d'accéder en lecture seule à un élément de la chaine
```csharp
name[1] // = 'z'
```
---
- Classe définie par l'utilisateur
```
class Student {
//
}
```
---
### Les interfaces
"Contrat" défini par l'utilisateur et qui doit être implémenté.
```csharp
interface I {
//
}
```
---
### Les tableaux
Structure de données permettant de stocker plusieurs variables du même type.
```csharp
//tableau unidimensionnel de 100 cases de type int
int[] tab_1 = new int[100];
//tableau unidimensionnel de 3 cases
int[] tab_2 = [5, 50, 60]
//tableau multidimensionnel de 3 lignes et 2 colonnes
int[,] tab_3 = new int[3,2]
int[,] tab_4 = { {..,..},
{..,..},
{..,..}};
// tableau en escalier (ou tableau de tableaux)
int[][] tab_5 = new int[3][];
tab_5[0] = [1, 4, 17, 10];
tab_5[1] = [6,66];
tab_5[2] = [1, 33, 5];
```
---
## Les instructions conditionnelles
if .. else if .. else
```csharp
if ( expression_booléenne ){
//intructions
}
else if ( expression_booléenne ){
//intructions
}
else {
//intructions executées si les toutes les expressions ne sont pas vraies.
}
```
----
l'instruction switch
```csharp!
switch (variable){
case valeur_1 :
//instruction
break;
case valeur_1 :
//instructions
break;
...
case valeur_n :
//instructions
break;
default :
//instructions
break;
}
```
---
## Les instructions itératives
While
```csharp
while ( condition ){
//instructions
}
```
```csharp
int x = 10;
while ( x > 0 ){
x--; // x = x - 1;
}
```
do ... While()
```csharp
do {
//instructions
} while ( condition );
```
```csharp
string answer;
do {
playGame();
Console.WriteLine("Replay ?");
answer = Console.ReadLine("Replay ?");
} while ( answer != "NON" );
```
----
La boucle ``for``
```csharp
for (instruction_1 ; condition_arret; instruction_2){
// instructions
}
```
- instruction 1 : exécuté 1 fois avant la première itération
- condition_arrêt : condition à vérifier pour arrêter la boucle
- instruction_2 : instructions exécutées à la fin de chaque itération
```csharp
for (int i = 100 ; i <= 500 ; i++){
if ( (i % 4) == 0 )
Console.WriteLine(i);
}
```
----
la boucle ``foreach``
utilisée pour itérer sur des tableaux
```csharp
foreach (type nomVariable in tableau)
{
// instructions
}
```
```csharp!
double[] temperatures = [12.5, 15, 13.2, 11.3, 10]
foreach (double temperature in temperatures)
{
Console.WriteLine(temperature);
}
```
---
## Votre premier programme
```csharp
using System;
public class Program // Le nom de cette classe n'est pas important
{
public static void Main() // Le nom de cette fonction est important
{
//instruction ...
}
}
```
---
## La programmation orientée objet (POO)
- Les **classes** et les **objets** sont les deux principaux aspects de la POO
----
----
----
- Une classe contient les attributs et les méthodes des objets qu'elle représente.
- A l'instantiacion, chaque objet pourra définir la valeur de ses attributs
```csharp!
/*En supposant que les classes Person, Fruit et Car ont été définies, voici un exemple d'instanciation de quelques objets.*/
Person p = new Person("Azzeddine", "Benabbou");
Fruit apple = new Fruit("Apple");
Fruit banana = new Fruit("Banana");
Car volvo = new Car("Volvo", 1990);
```
----
### Création d'une Classe
- Les attributs peuvent être publiques ou privés (par défaut)
```csharp!
public class Car{
private string brand;
private int nbDoor;
string model;
}
```
----
- Les méthodes peuvent être publiques ou privées.
```csharp!
public class Car{
private string brand;
private int nbDoor;
string model;
public void displayCarInfo(){
Console.WriteLine( "Brand : " + this.brand );
Console.WriteLine( "Number of doors : " + this.nbDoor );
Console.WriteLine( "Model : " + this.model );
}
}
```
----
- Le constructeur est une méthode spéciale appelée lorsqu'un objet est instancié
- a le même nom que la classe
- n'a pas de type de retour
```csharp!
public class Car{
//Atrributes
private string brand;
private int nbDoor;
string model;
//Constructor 1
public Car(){
this.brand = "";
this.nbDoor = 5;
this.model = "";
}
//Constructor 2
public Car(string brand, int nbDoor, string model){
this.brand = brand;
this.nbDoor = nbDoor;
this.model = model;
}
//Methods
public void displayCarInfo(){
Console.WriteLine( "Brand : " + this.brand );
Console.WriteLine( "Number of doors : " + this.nbDoor );
Console.WriteLine( "Model : " + this.model );
}
}
```
----
- Les getters et les setters (en Java)
```csharp!
public class Car{
//Atrributes
private string brand;
private int nbDoor;
string model;
...
public string getBrand {
return brand;
}
public void setBrand (brand) {
this.brand = brand
}
}
```
```
Car c = new Car(); // instancie un objet
c.setBrand("Audi"); // modifie un attribut grâce au Setter
Console.WriteLine(c.getBrand()); Récupère sa valeur grâce au Getter
```
----
En C#, il existe ce qu'on appelle les Properties
```csharp!
public class Car{
//Atrributes
private string brand;
public string Brand{
get {return brand;}
set {return value;}
}
private int nbDoor;
string model;
...
}
```
```
Car c = new Car(); // instancie un objet
c.Brand("Audi"); // modifie un attribut grâce au Setter
Console.WriteLine(c.Brand); Récupère sa valeur grâce au Getter
```
----
On peut le rendre plus compact s'il n'y a pas d'avantage d'instructions dans le get et set
```csharp!
public class Car{
//Atrributes
private string Brand {get; set;};
private int nbDoor;
string model{get; set;};
...
}
```
----
Exemple avec des instructions dans le setter
```csharp!
public string Brand {get; set;}
private int nbDoor;
public int NbDoor {
get { return nbDoor; }
set{
if(value != 3 && value != 5)
return;
nbDoor = value;
}
}
public string Model {get; set;}
```
---
---
## Les collections
- Permettent de stocker et manipuler des données similaires
- Offrent de nombreuses méthodes
----
### Exemple de collections avec élément à une valeur
- Array
- List<T>
- Queue
- Stack
----
### Exemple de collections avec élément à clé/valeur
- Hashtable
- SortedList<TKey,TValue>
- Dictionary<TKey,TValue>
---
Exemple
```csharp!
List<int> l = new List<int>();
l.Add(5); // ajoute 5 à la liste
l.Add(2); // ajouter 2 à la liste
l.RemoveAt(1); // supprime la valeur qui se trouve à l'indice 1
Dictionary<string, int> panier = new Dictionary<string, double>();
panier.Add("Chemise", 2);
panier.Add("Jean", 1);
```
---
{"title":"Slides C#","description":"View the slide with \"Slide Mode\".","contributors":"[{\"id\":\"a90fc05d-2c7a-41b1-b785-a065fb26c58d\",\"add\":11214,\"del\":2873}]"}