The domain name sam-mag.com is available for sale!

Un type d'objet ou classe d'objet est déclaré en utilisant le mot clef class.

class User {

  }

Membres d'une classes
Une classe peut contenir les membres suivant:

L'exemple suivant montre une classe implémentant les différents membres :

class Document {
	public Document () {				// Constructeur d'instance
	}
	public Document (string doc_title) {
		title = doc_title;				// Constructeur d'instance
	}
	public const int MAX_LINE = 100;			// Constante
	private string title;				// Champ
	public void Save() {				// Methode
		...
	}
	public string Title {				// Propriete
		get {
			return title;
		}
		set {
			title = value;
		}
	}
	public int this[int index] {			// Indexeur
		get {
			...
			return 0;
		}
		set {
			....
		}	
	}
	public event EventHandler Modified;			// Evenement
	public static Document operator+(Document a, Document b) {	// Operateur
		....
		return new Document();
	}
	internal class SousDocument {}			// Classe imbriquée
}

Accessibilité des membres d'une classe
Chaque membre d'une classe possède un niveau d'accessibilité qui défini son mode d'accès par les utilisateurs de l'objet.
En C#, cinq formes d'accessibilités sont possibles :

Tableau récapitulatif des modificateur d'accès :

Héritage
Les classes supportent l'héritage de classe, processus par lequel une classe dérivée peut étendre et spécialisée une classe de base.

Pour dériver une classe d'une autre classe d'objet, on utilise le caractère " : " suivant la déclaration de la classe suivie de nom de la classe de base. La classe dérivée hérite des caractéristiques de la classe d'origine.

class User 
{
}


class Abonne : User 
{
}

En C#, toutes les classes dérivent implicitement de la classe de base object.

Constructeur

Le constructeur d'une classe est un membre de classe qui implémente les actions nécessaires à l'initialisation d'une instance de la classe.
Un constructeur possède le même nom que la classe. Il peut contenir un modificateur d'accès, et ne retourne aucun paramètre.

class User {
  public User () {

  }
}

Plusieurs constructeurs peuvent être définis pour une même classe. Le nombre et/ou le type de paramètre doivent être différents. Le constructeur adéquat sera appelé en fonction du type et du nombre de paramètres.

class User {
  private string name;
  public User () {
	name = "";
  }
  public User (string Name) {
	name = Name;
  }
}

L'appel au constructeur d'une classe se fait automatiquement lors la création d'instance d'un objet (par l'opérateur new).

class Test {
	User user = new User();
}

Destructeur

Le destructeur d'une classe est un membre de classe qui implémente les actions nécessaires pour détruire une instance de la classe.
Un destructeur de classe possède le même nom que la classe, précédé du caractère ~.

class User {
	public User () {
		Console.WriteLine("In constructor");
	}
	~User () {
		Console.WriteLine("In destructor");
	}
}

Un destructeur de classe ne peut pas être appelé directement. Le destructeur est appelé automatiquement lors de la gestion automatique de la mémoire (garbage collection).

Un destructeur ne possède ni paramètre, ni modificateur d'accessibilité.
Il ne peut exister qu'un seul destructeur de classe.

Constantes

En C#, une constante doit être déclarée comme membre d'une classe. Une constante décrit une valeur fixe, elle peut être une valeur calculée et dépendre d'une autre constante. Sa valeur doit pouvoir être calculée au moment de la compilation.

Une valeur constante est déclarée par le mot clef const.

const type identifier = constant-expression

class A {
	const bool VRAI 		 = true ;
	const int MAX_VALUE 	 = 100;
	const double LONG_MAX	 = 500.80 ;
	const string HELLO 	 = "Hello";
	const double LARG_MAX 	 = LONG_MAX / 3.5;
}

Une constante peut être d'un type par valeur : bool decimal sbyte byte short ushort int uint long ulong char float double, un type énumération ou string.

Une constante peut être une valeur fixe connue, ou une expression. L'expression doit pouvoir être évaluée au moment de la compilation.
Une constante peut dépendre d'une autre constante.

Une constante est un membre de classe, elle bénéficie donc d'une déclaration d'accessibilité, comme tout membre de classe. L'accès à la valeur constante sera donc limité à la classe (private), à la classe ou aux classes dérivées ( protected), au programme (internal), au programme et aux classe dérivées (protected internal), ou à tout le monde (public).

L'accès aux constantes s'effectue par le biais de la classe et non de l'instance de l'objet.

class A 
{
	const string HELLO = "Hello";
}

class B 
{
	string s = A.HELLO;
}

Une constante est considérée comme un membre static de la classe bien que la déclaration de constante ne nécessite ni n'autorise le modificateur static, cette déclaration est implicite.

Champs

Un champ représente une donnée variable d'une classe. Il représente un espace de stockage au sein de la classe.

type identifier [ = value ]

class User
{
	public 		int age;
	protected 	string name;
	private		int type_user = 1;
}

Un champ peut être d'un type pré-défini par valeur ou par référence,.en fait tout type d'objet.

Une variable peut être initialisée lors de la déclaration ou dans le constructeur de l'objet.
La valeur du champ peut être une valeur fixe, ou une valeur calculée (expression).

Méthodes

Une méthode est un membre d'une classe qui implémente une action. Une méthode peut accepter des paramètres et renvoyer des valeurs de retour.

class User
{
	public		bool Recherche(string name) { ... }
	public 		void Delete() { ... } 	
}

Le type de retour d'une méthode peut être un type pré-défini par valeur (int, bool, ..) ou de tout type d'objet (class).Si aucun paramètre n'est retourné, la méthode est de type void.

Les méthodes d'une classe peuvent être surchargées. Ceci signifie qu'ils peut exister plusieurs méthodes de même nom qui se distinguent par le nombre ou le type de paramètre. Le paramètre de retour ne peut pas être utilisé comme méthode surchargée.

Une méthode peut être déclarée statique (static) ou non statique (par défaut).
L'accès à une méthode static s'effectue par l'intermédiaire de la classe. L'accès à une méthode non statique s'effectue par l'instance de l'objet.

Propriétés

Une propriété est un membre d'une classe permettant d'accéder ou de modifier les caractéristiques d'un objet. Une propriété peut être en lecture seule, écriture seule ou en lecture / écriture. Une propriété ne représente pas l'emplacement de stockage d'une valeur mais d'une fonction (accesseur) qui permet de lire ou écrire les caractéristiques d'un objet.

Une propriété comprend un accesseur get qui permet de retourner une valeur et un accesseur set qui permet de modifier une valeur.

class User
{
	private int age;


	public 	int Age {
		get {
			return age;
		}
		set {
			age = value;

		}

	}
}

Une propriété est en lecture seule si l'accesseur set est absent. Elle est en écriture seule, si get est absent.
L'opérateur value représente la valeur en écriture, quel que soit son type.

class Test
{
	private User user;


	public 	Test () {
		user = new User;
		int age = user.Age;		// Get
		user.Age = age + 1;		// Set
		user.Age += 1;			// Get / Set

	}
}