Programmation C sharp/Les classes
La notion de classe est à la base de la programmation orientée objet. Elle définit un type d'objet. Ce type rassemble des variables (créées pour chaque objet et appelées « attributs ») et des fonctions (appelées dans ce cas « méthodes »).
Ces attributs et méthodes sont les « membres » de la classe. Ils peuvent avoir chacun un niveau de protection différent.
Déclarer une classe.
La déclaration d'une classe utilise le mot clé codice_1 :
 class "nom_de_la_classe"
Les membres sont définis à l'intérieur des accolades.
Exemple :
class Fraction
 int numerateur,
 denominateur;
 void multiplier(Fraction autre)
 this.numerateur *= autre.numerateur;
 this.denominateur *= autre.denominateur;
Membres d'une classe.
Les membres d'une classe sont de différents types :
Membres statiques de classe et membres d'instance.
Un membre statique de classe est un membre déclaré avec le mot clé codice_2. Il est défini une seule fois en mémoire, et il n'est pas nécessaire de créer un nouvel objet pour qu'il soit créé et utilisable.
Un membre d'instance est déclaré sans le mot clé codice_2. Il n'est créé que pour chaque objet (une instance) créé par l'opérateur codice_4.
Exemple :
public class UnExemple
 int numero; // Défini pour chaque objet
 static int numero_suivant; // Défini pour la classe
Console.WriteLine("N° suivant = " + UnExemple.numero_suivant );
Console.WriteLine("N° = " + UnExemple.numero );
// Erreur de compilation, car la variable n'est pas définie pour la classe
UnExemple InstanceDUnExemple = new UnExemple();
Console.WriteLine("N° = " + InstanceDUnExemple.numero );
Classe statique.
Une classe statique ne contient que des membres statiques, et ne peut être instanciée. Le mot clé codice_2 précède la déclaration de cette classe.
Exemple :
public static class UneClasseStatique
 public static void Afficher(string message)
 // ...
UneClasseStatique.Afficher("Un exemple de message");
Instance d'une classe.
L'instance d'une classe est aussi appelée un objet. Une variable de ce type est un type référence, c'est à dire que la référence est nulle par défaut. Il faut donc utiliser le mot clé codice_4 pour allouer une instance de la classe.
Exemple :
UnExemple objetExemple; // par défaut : null
// Equivaut à UnExemple objetExemple = null;
objetExemple = new UnExemple();
Le mot clé new est suivi du nom de la classe et d'une liste de paramètres entre parenthèses. Il s'agit en fait d'un appel au constructeur (abordé plus loin dans ce chapitre) initialisant l'objet créé.
La référence nulle.
Toute variable de type objet est en fait une référence initialisée à codice_7 par défaut.
Cette référence peut être utilisée quel que soit le type d'objet.
Il est souvent nécessaire de tester si la référence est nulle avant d'accéder à un membre de l'objet référencé. Si le test n'est pas fait et que la référence est nulle, une exception est levée.
Niveaux de protection.
Le niveau de protection est spécifié par un mot clé placé avant la déclaration d'une classe ou d'un membre de classe (attribut, méthode, propriété, ...) :
Exemple :
public class Fraction
 private int
 numerateur,
 denominateur;
 public void multiplier(Fraction autre)
En général, les règles de l'encapsulation sont les suivantes :
Constructeur.
Un constructeur est une méthode spéciale portant le nom de la classe, ne retournant aucune valeur, chargée d'initialiser l'instance. Un constructeur peut avoir des paramètres permettant de définir les valeurs initiales des attributs du nouvel objet.
Une classe possède souvent plusieurs constructeurs. Chacun possédant une liste d'arguments différente.
Exemple.
Pour initialiser une fraction :
public class Fraction
 private int
 numerateur,
 denominateur;
 // Constructeur
 public Fraction(int numerateur, int denominateur)
 // this est utilisé pour désigner les attributs de l'objet
 // plutôt que les paramètres
 // recopie des paramètres :
 this.numerateur = numerateur;
 this.denominateur = denominateur;
 public void multiplier(Fraction autre)
Utilisation :
Fraction estimation_pi = new Fraction( 355 , 113 );
Constructeur par défaut.
Le constructeur par défaut est celui qui n'a aucun paramètre. Si aucun constructeur n'est déclaré dans une classe, le compilateur crée un constructeur par défaut qui ne fait rien, laissant les attributs à leur valeur par défaut (dépendant du type : 0 pour les numériques, null pour tous les autres).
En fait, ce constructeur par défaut appelle le constructeur sans argument (qu'il soit par défaut ou explicitement implémenté) de la classe de base (codice_12 par défaut). Voir le chapitre sur l'héritage de classe.
Constructeur statique.
Il est possible d'exécuter un code lors de la première utilisation de la classe.
Cette initialisation peut être vue comme un constructeur statique :
public class Fraction
 private static int valeur;
 static Fraction()
 valeur = 1;

Programmation C sharp/Structures et énumérations

Structure.
Une structure rassemble plusieurs champs (des variables) en un seul type. Déclarer une variable de ce type revient à allouer de la place pour tous les champs déclarés.
Syntaxe.
 struct "nom_de_structure"
 "type" "variable";
Exemple :
struct Point
 public double x;
 public double y;
Méthodes.
Comme pour une classe, il est possible d'ajouter des méthodes.
Exemple :
struct Point
 public double x;
 public double y;
 public void MoveTo(double x,double y)
Différences avec les classes.
Il est possible d'assimiler les structures à des classes, cependant des différences existent :
Exemple pour illustrer ce dernier point :
Point origine; // alloué en mémoire à la déclaration
origine.x = 0.0;
origine.y = 0.0;
Passage d'une structure en paramètre.
Le passage d'une structure en paramètre d'une fonction peut se faire de deux manières :
Énumération.
Une énumération est un type de données dont les valeurs sont des constantes nommées.
Syntaxe.
 enum "nom_énumération"
 "nom", "nom" "..."
Exemple :
enum JourDeSemaine
Type des constantes.
Les constantes d'une énumération sont par défaut des entiers (codice_5) dont la valeur augmente de un, en commançant par zéro.
Ce qui veut dire que dans l'exemple précédent, codice_6 vaut 0, codice_7 vaut 1, etc.
Une constante peut être convertie en entier :
Console.WriteLine("Lundi : "+JourDeSemaine.LUNDI);
// affiche Lundi : LUNDI
Console.WriteLine("Lundi : "+(int)JourDeSemaine.LUNDI);
// affiche Lundi : 0
Il est possible de modifier les valeurs affectées aux constantes :
enum JourDeSemaine
Par défaut, chaque constante est associée à la valeur immédiatement supérieur à celle de la constante précédente. L'exemple précédent peut donc également s'écrire :
enum JourDeSemaine
Il est également possible de modifier le type des constantes :
enum JourDeSemaine : long
Combinaison de constantes.
En affectant des valeurs différentes de puissances de 2 aux constantes, l'opérateur ou ( codice_8 ) est utilisable pour combiner plusieurs constantes.
Exemple :
[Flags]
enum Droits
 LECTURE = 1,
 ECRITURE = 2,
 EFFACER = 4
Droits d = Droits.LECTURE | Droits.EFFACER;
Console.WriteLine("droits : "+d);
// affiche droits : LECTURE, EFFACER
Console.WriteLine("droits : "+(int)d);
// affiche droits : 5
L'attribut codice_9 indique au compilateur que plusieurs constantes peuvent être combinées. La méthode codice_10 de cet codice_11 affiche alors toutes les constantes utilisées.
L'opérateur et ( codice_12 ) permet de tester si une constante appartient à l'ensemble :
if ( (d & Droits.LECTURE) != 0) Console.WriteLine(" lecture autorisée");
if ( (d & Droits.ECRITURE) != 0) Console.WriteLine(" écriture autorisée");