Définition

Tous les membres d’une classe ou d’une structure (à l’exception des champs et des constantes) sont des fonctions membres :

• Méthodes
• Propriétés
• Événements
• Indexeurs
• Opérateurs définis par l’utilisateur
• Constructeurs
• Destructeurs

Le polymorphisme

Le polymorphisme  est un concept très important en CSharp. Ploy signifie plusieurs et morphisme signifie forme. Uniquement les méthodes et les propriétés (accesseurs) peuvent être polymorphes dans une classe.

Exemple

Une méthode appelée DessinePorte. On peut associer cette méthode avec divers objets qui représentent les différents types de fenêtres.

monBouton.DessinePorte(); // dessine un bouton
monMsg.DessinePorte(); // dessine une message box
maSurface.DessinePorte(); //dessine une porte à peindre

Méthodes virtuelles et redéfinies

Pour utiliser les méthodes polymorphes, on déclare la méthode DessinePorte() avec le
mot-clé virtual dans la classe de base.

public virtual void DessinePorte() { }

Ensuite, dans chacune des classes qui héritent de la classe de base, on déclare une méthode DessinePorte() en utilisant le mot-clé override.

public override void DessineFenetre() { }

Redéfinition de méthode

On peut redéfinir une autre méthode qui a le même nom, la signature et la même accessibilité que dans la classe de base. Quand on redéfinit une méthode, on peut changer son comportement d’origine dans la classe dérivée. Une méthode redéfinie peut redéfinir toutes les méthodes déclarées avec les modificateurs suivants:

• virtual
• abstract
• override

Pour qu’une méthode redéfinisse celle de la classe de base, il faut modifier sa déclaration avec le mot-clé override.
Une méthode abstraite est implicitement virtuelle, et donc peut-être redéfinie sans utiliser le modificateur virtual .
On ne peut pas utiliser le modificateur virtual avec les modificateurs suivants:
static, abstract ou override.
On ne peut pas combiner le modificateur override avec les modificateurs suivants:
static, abstract, virtual ou new.

Appel aux Membres de la Classe de base

Si on désire appeler une méthode redéfinie de la classe de base on utilise le mot-clé base.

base.GetInformation();

On ne peut pas utiliser le mot-clé base dans une méthode statique.
S’il est nécessaire de construire l’objet de la classe de base avant de construire l’objet de la classe dérivée, on appelle le constructeur ainsi :

public MaDerivee(int y) : base(z) { }

Classes et méthodes abstraites

Le but d’une classe abstraite est d’être héritée par d’autres classes. Elle ne peut donc pas être instanciée. Une méthode abstraite est, par défaut, une méthode virtuelle. Elle ne peut exister qu’à l’intérieur d’une classe abstraite.

abstract class MaBaseClasse // classe abstraite
{
public abstract void MaMethode(); // méthode abstraite
}

Surcharge de méthodes

La surcharge de méthodes consiste à donner le même nom à plus d’une méthode et laisser le compilateur charger la méthode appropriée en fonction du nombre et du type de paramètres.

void MaMethode(int x1) { }
void MaMethode(int x2, int x3) { }

Passage de paramètres

Deux façons de passer un paramètre à une méthode :

• par valeur (passage par défaut).
• par référence.

Passage par référence

Le passage de paramètres par référence permet de modifier les valeurs des variables de manière persistante. Pour passer un paramètre par référence, on déclare le paramètre avec le mot-clé ref.

Il y a trois modificateurs de paramètres, qui permettent la modification de la valeur des variables après le retour à la méthode appelante. Ces trois modificateurs sont : ref, out et params.

Lorsqu’on utilise ref pour passer une variable à une méthode, la variable doit être initialisée en premier, sinon on génère une erreur du compilateur.
Le modificateur out ne nécessite pas l’initialisation de la variable avant de la transmettre à la méthode, mais l’initialisation doit se faire dans la méthode elle-même.

Les indexeurs

Les indexeurs, permettent de manipuler des classes comme des tableaux ou des collections. On peut donc accéder aux éléments de l’indexeur en utilisant les crochets ([]).
Un indexeur est similaire aux propriétés puisqu’il peut aussi utiliser les accesseurs get et set pour exprimer ses caractéristiques.
La déclaration d’un indexeur est de la forme:

indexer-type this [parameter-type parameter]
{
get {};
set {};
}

indexer-type est le type de l’indexeur.
parameter-type est le type du paramètre.
parameter est un paramètre ou une liste de paramètres

La surcharge des opérateurs

La surcharge permet d’assigner de nouveaux rôles pour certains opérateurs. Par exemple, on peut surcharger l’opérateur ‘+’ pour la classe Point :

public static Point operator+(Point p1, Point p2)
{
// Implémentation de l’opérateur +
// Voir exemple
}

Les attributs

Les attributs sont des informations additionnelles qui permettent de modifier les déclarations des entités de programme (types, membres, paramètres, etc., …). Ils servent à différentes choses comme par exemple marquer une méthode comme obsolète, indiquer une compilation conditionnelle, …
Ils sont dérivés de la classe abstraite System.Attribute. L’attribut est mis entre [].