Actualites  Archives
 Inscription | Plan du site | 2  visiteurs actifs  
  
     A la Une
  Actualités
  Dossiers
  Coin Technique
  Annonces Web
  Référencement

     Diagnostic
  Popularité Site Web
  Positionnement Moteur
  WebPage Alerte
  Positionnement Google

     Archives
  Sélection
  Expérience qui parle
  Internet quotidien
  Tous les dossiers

     Services
  Communiqués de Presse

     Contact
  Nous contacter
  La protection des données personnelles

     Technique
  Merise

     Login
   
    
Inscription

Mot de passe oublié?

   Sondage
Les points que vous souhaitez voir traiter à l'avenir ?
5%Actualité
28%Documentation
53%Exemples de sources
3%Liste de liens
11%Revue logiciels

   Sondage
Vous vous intéressez plutôt à
77%Programmation
11%Système
8%Logiciel
5%Matériel

   Sondage
votre niveau technique ?
15%Amateur
46%Débutant
32%Professionnel
7%Expert

     Rechercher
    
   

 Actualités > Coin Technique


Introduction aux objets en C# (2eme partie)
Evénements, Indexeurs et Opérateurs.

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

 

 Imprimer Donner votre avis

 
 

Sam-Mag - Un site du réseau ACORUS 1996-2007
© Copyright ACORUS All rights reserved.- Mentions légales

Ce site respecte la loi Informatique et Libertés. Pour en savoir plus sur la protection des données personnelles, cliquez

 
Webmaster