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