Evénement
Un événement est un membre permettant de fournir des notifications.
Les clients utilisateurs de l'objet peuvent attacher un code qui sera exécuté
lors du déclenchement de l'événement.
Les utilisateurs Visual Basic ont l'habitude de gérer des événements
sur des interfaces utilisateurs : clic sur un bouton, par exemple.
En C#, il est possible à une classe de spécifier des événements
disponibles aux utilisateurs de l'objet. Cette possibilité trés
pratique en conception objet, permet des développements très modulaires.
Une classe document peut ainsi prévenir de la modification d'un document,
de sa sauvegarde, etc....
Un événement est défini à l'aide d'une déclaration
event. Le type de cette déclaration doit être un type délégué.
Le type délégué EventHandler fourni par Le .Net
Framework peut être utilisé ou vous pouvez lui substituer votre
propre délégué.
Déclaration d'un événement
public event EventHandler Modified;
Appel d'un événement
L'appel de l'événement s'effectue en appelant l'événement
:
Modified(this, e);
L'événement est ici de type EventHandler :
public delegate void EventHandler(object sender, System.EventArgs e);
Raccordement à un événement
Le client de l'objet doit déclaré un délégué
(une méthode) de type événement qui sera exécuté:
private void DocModified(object sender, EventArgs e)
{
....
}
Il connecte ensuite ce délégué à l'événement.
doc.Modified += new EventHandler(DocModified);
Lorsque l'événement Modified sera déclenché par
l'objet, le délégué DocModified du client sera exécuté.
Exemple
public class Doc
{
private string mTitle;
// Déclaration de l'événement
public event EventHandler Modified;
public Doc()
{
}
protected virtual void OnModified(EventArgs e)
{
// Le champ est null si le client n'a pas raccordé un délégué à l'événement
// Appel de l'événement, le code attaché par le client est exécuté
if (Modified != null)
Modified(this,e);
}
public void ChangeTitle(string title)
{
mTitle = title;
// Déclenche l'évenement
OnModified(EventArgs.Empty);
}
public string Title
{
get
{
return mTitle;
}
}
}
class Test
{
public Test()
{
Doc doc = new Doc();
// Attache l'évemenent
doc.Modified += new EventHandler(DocModified);
doc.ChangeTitle("TEST");
}
// Le délégué appellé lors du déclenchement de l'événement est de type EventHandler
// public delegate void EventHandler(object sender, System.EventArgs e);
private void DocModified(object sender, EventArgs e)
{
Doc doc = (Doc) sender;
Console.WriteLine("Document modifié : " + doc.Title);
}
static void Main()
{
Test app = new Test();
}
}
Notez que EventHandler reçoit une instance de l'objet déclencheur
de l'événement : sender
Si vous souhaitez envoyer des paramètres supplémentaires,
dérivez une classe de System.EventArgs, déclarez un nouveau type
délégué basé sur cette classe en lieu et place de
EventHandler.
Indexeur
Un indexeur est un membre de classe permettant d'accéder à un
objet à la manière d'un tableau.
Un indexeur se déclare de façon similaire à une propriété,
dont le nom est this.
Tout comme pour une propriété, la présence des accesseurs
get et set indique si l'indexeur est en lecture seule ou écriture
seule.
L'indexeur peut retourner n'importe quel type de valeur.
class ListIndexer
{
string[] list = new string[] {"first", "second", "third" };
public string this[int index]
{
get
{
if (index < list.Length)
return list[index];
else
return string.Empty;
}
set
{
if (index < list.Length)
list[index] = value;
}
}
}
class Test
{
static void Main()
{
ListIndexer li = new ListIndexer();
string s = li[0];
li[1] = "test";
}
}
Un indexeur peut servir à retourner un membre liste ou tableau privé
de la classe, mais pourquoi pas une valeur calculée :
class Multiple
{
public int this[int index]
{
get
{
return index * 2;
}
}
}
class Test
{
static void Main()
{
Multiple m = new Multiple();
int v = m[2];
Console.WriteLine(v);
}
}
Opérateur
Un opérateur permet de spécifier des résultats d'opérations
à appliquer sur l'objet.
Trois catégories d'opérateurs sont disponibles :
- les opérateurs unaires :
(+, - , !, ~, ++, --, true, false)
- les opérateurs binaires :
(+, -, *, /, %, &, |, ^, <<, >>, ==, !=, >, <, >= ou <=)
- les opérateurs de conversion
Une déclaration d'opérateur doit inclure un modificateur à la fois public et
static.
Des règles vont s'appliquer ensuite en fonction du type d'opérateur
choisi.
public class Class2
{
private static int x = 10;
public Class2()
{
}
public static int operator+(Class2 a, int b)
{
return (x + b);
}
public static bool operator==(Class2 a, int b)
{
return (x == b);
}
public static bool operator!=(Class2 a, int b)
{
return (x != b);
}
}
class Test
{
static void Main()
{
Class2 c = new Class2();
int r = c + 10;
Console.WriteLine(r);
}
}
L'opérateur + n'accepte qu'un seul paramètre de type Class2 et
peur retourner n'importe quel valeur.
Les opérateurs de comparaison doivent être déclarés
par couple :
operator == et operator !=
operator > et operator <
operator >= et operator <=
Jérôme Lacaille
Conception et réalisation d'applications Internet
|