C Sharp

Sommaire
Le langage
Les variables et les constantes

Les types de base et les dclarations
Les tableaux
Les objets
Les classes
Les fonctions
Proprits et indexeurs
Hritage de classes
Classe abstraite
Les exceptions
Programmation avance
Surcharge des oprateurs
Les variables et les constantes

Sections
[masquer]
1 Les variables
1.1 Dclaration
1.2 Utilisation
1.3 Porte d'une variable
1.4 Dure de vie d'une variable
1.5 Variable en lecture seule
2 Les constantes
2.1 Dclaration
2.2 Types des constantes
2.3 Porte et dure de vie d'une constante
[modifier]Les
variables
Une variable rserve une place en mmoire pour stocker des donnes : rsultats d'expressions,
donnes lues depuis un fichier, ... Elle est associe un nom.
[modifier]Dclaration
Une variable possde un nom et un type. Ce type dtermine ce que peut stocker la variable : un
nombre, une chane de caractre, un objet d'une classe particulire ...
La syntaxe est la suivante :
type nom [ = expression ] ;
Exemples :
double prix_unitaire;
int quantite = 50;
string article = "Pommes";
bool rabais = false;
Assigner une variable (initialiser) la dclaration n'est pas obligatoire. Dans ce cas, elle possde la
valeur par dfaut correspondant au type :
la valeur par dfaut des types numriques et caractres (char) est zro (0),
la valeur par dfaut du type boolen (bool) est false,
la valeur par dfaut des types rfrences (objet, chane de caractre, tableaux) est null,
la valeur par dfaut des types numrs (enum) est celle qui correspond au type sous-jacent
(int par dfaut).
Il est possible de regrouper la dclaration de plusieurs variables du mme type en utilisant une virgule
pour sparer les diffrentes variables.
Exemple :
int quantite = 50, nombre, quantite_en_stock = 100 ;
Ou en plaant une variable par ligne pour plus de clart :
int quantite = 50,

nombre,
quantite_en_stock = 100 ;
[modifier]Utilisation
Une variable est utilise pour stocker des rsultats intermdiaires, des donnes qui serviront
ultrieurement. La valeur d'une variable peut tre modifie autant de fois que ncessaire.
Exemple :
prix_unitaire = 1.50;
if (rabais) prix_unitaire = prix_unitaire - 0.20;
double prix_total = prix_unitaire * quantite ;
[modifier]Porte d'une variable
La porte d'une variable est l'ensemble des emplacements dans le code o cette variable est
accessible. En dehors de cette porte, l'utilisation du mme nom correspondra une autre variable ou
plus souvent aucune variable (erreur de compilation dans ce cas).
La porte d'une variable correspond au bloc d'accolades o elle est dclare. Une variable membre
d'une classe est dclare au niveau de la classe et est accessible depuis les autres membres de la
classe (mthodes, indexeurs, proprits, ...). Une variable locale est dclare l'intrieur d'un bloc
d'accolades (celui de la mthode/proprit membre, ou un bloc interne celle-ci).
Exemple :
public class Exemple
{
// variable membre de la classe :
int nombre = 5; // porte : la classe Exemple
public int MethodeUne()
{
// variable locale la mthode :
int nombre = 10; // porte : la mthode MethodeUne()
return nombre +
// la variable locale
this.nombre; // la variable membre
// retourne 10 + 5 , c'est dire 15
}
public int MethodeDeux()
{
System.Console.WriteLine("Nombre = " + nombre); // la variable
membre
// Nombre = 5
{
int nombre = 20; // variable locale au bloc d'accolades

locale
// Nombre = 20
} // la variable locale est hors de porte
membre
// Nombre = 5
}
}
[modifier]Dure
de vie d'une variable
La dure de vie d'une variable est la priode durant laquelle une variable existe, c'est dire conserve
son emplacement en mmoire et durant laquelle elle peut donc stocker des donnes.
[modifier]Variable
en lecture seule
Une variable peut tre dclare en lecture seule en utilisant le mot-cl readonly.
Exemple :
readonly double taux_tva = 19.6;
Il n'est pas obligatoire d'initialiser une variable en lecture seule lors de sa dclaration. Ce qui permet
de dterminer la valeur en fonction d'autres donnes, ou de lire sa valeur depuis un fichier par
exemple, et d'empcher sa modification aprs affectation.
Exemple :
class Facture
{
public readonly double taux_tva;
public Facture(bool taux1)
{
if (taux1) taux_tva = 19.6;
else taux_tva = 5.5;
}
}
[modifier]Les
constantes
Une constante nomme est associe une valeur pour toute la dure de l'application. Sa valeur ne
peut changer.
La syntaxe est similaire celle de la dclaration d'une variable, except que le mot
cl const prcde la dclaration, et que l'initialisation la dclaration est obligatoire :
const type nom = expression ;
Exemple :
const double prix_unitaire_unique = 1.50 ;

const double taux_euro_en_francs = 6.55957 ;
Comme les variables il est galement possible de regrouper la dclaration de plusieurs constantes du
mme type :
const double
prix_unitaire_unique = 1.50 ,
taux_euro_en_francs = 6.55957 ;
N.B.: Une constante est implicitement statique. Il est donc inutile d'ajouter le mot-cl static, sinon le
compilateur gnre une erreur.
[modifier]Types
des constantes
Le mot const ne s'applique qu'aux types standards numriques, boolens, string, et numrations.
[modifier]Porte
et dure de vie d'une constante
Les mmes rgles que celles pour les variables s'appliquent galement aux constantes.
Les types de base et les dclarations

En C#, il existe deux catgories de type :
Les types valeurs qui stockent directement la valeur des donnes (un entier, une chane de
caractres, une structure),
Les types rfrences qui stockent une rfrence vers la valeur des donnes (un tableau, un objet,
une interface). Les variables de ce type se distinguent par le fait qu'elles valent
initialement null et qu'il faut explicitement leur allouer de l'espace mmoire avec new. Les
donnes rfrences par ces variables sont donc soumises au garbage collector quand plus
aucune rfrence n'existe, afin de librer la place mmoire occupe.
Un type de base est un type simple valeur.

Sections
[masquer]
1 Liste des types de base
2 Syntaxe des chanes de caractres
3 Auto-boxing/unboxing
4 Types nullable
5 Valeur par dfaut
6 Obtenir le type
[modifier]Liste
Type
des types de base

Classe
Description
Exemples
bool
System.Bool
Boolen (vrai ou faux : true ou false) true
char
System.Char
Caractre Unicode (16 bits)
'A'
sbyte
System.SByte
Entier sign sur 8 bits (1 octet)
-128
byte
System.Byte
Entier non sign sur 8 bits (1 octet)
255
short
System.Int16
Entier sign sur 16 bits
-129
ushort
System.UInt16
Entier non sign sur 16 bits
1450
int
System.Int32
-100000
uint
System.UInt32
8000000
long
System.Int64
-2565018947302L
ulong
System.UInt64
8000000000000L
float
System.Single
Nombre virgule flottante sur 32 bits
3.14F
double System.Double Nombre virgule flottante sur 64 bits
3.14159
decimal System.Decimal Nombre virgule flottante sur 128 bits
3.1415926M
string
"Exemple"
"C:\\windows\\system32"
@"C:\windows\system32"
System.String
[modifier]Syntaxe
Chane de caractres
des chanes de caractres
Comme illustr par l'exemple du tableau ci-dessus, une chane de caractres peut avoir deux
syntaxes diffrentes :
Syntaxe avec caractres d'chappement : La chane est entoure par les guillemets et l'anti-slash
introduit un caractre spcial (\n, \t ...) ou empche son interprtation (guillemet \" et antislash \\)
Syntaxe verbatim : La chane est prcde d'un caractre arobase, et l'anti-slash n'est pas
interprt. Si un guillemet doit faire partie de la chane de caractre, il faut le doubler "".
Exemples :
"un guillemet \", un anti-slash \\, un retour la ligne\n"
@"un guillemet "", un anti-slash \, un retour la ligne
"
La syntaxe verbatim simplifie la frappe des chemins de fichiers qui utilisent le caractre anti-slash
comme sparateur :
@"C:\program files\monapp\monfichier.txt"
[modifier]Auto-boxing/unboxing
Chaque type de donnes correspond une classe de l'espace de nom System. La conversion entre
le type et une instance de cette classe est implicite et invisible.
Ainsi, on peut appeler des mthodes sur les types simples, affecter une constante o une classe de
type est attendue (et vice versa), ...
Exemple :
int a = 25;
string message = 36.ToString(); // convertit 36 en chane de caractres,
// mthode dfinie dans la classe
System.Int32
UInt32 b = 50;
[modifier]Types
nullable
Le langage C#2.0 introduit la possibilit pour les types simples de valoir null. Cette fonctionnalit
permet une meilleure interoprabilit avec les bases de donnes qui utilisent ce type de donnes.
Pour qu'une variable puisse valoir null (nullable), il faut que le type soit suivi d'un point
d'interrogation. Par exemple :
int? numero = null;
Il est donc possible de tester qu'une variable de ce type vaut null :
if (numero==null) numero = 50;
else numero++;
Le nouvel oprateur ?? (double point d'interrogation) permet de slectionner l'oprande de gauche s'il
ne vaut pas null, ou l'oprande de droite sinon :
valeur_ou_null??valeur_si_null
Cet oprateur est donc pratique utiliser avec les types nullables pour obtenir une valeur par dfaut :
Console.WriteLine("Numro : "+( numero??50 ));
[modifier]Valeur
par dfaut
L'oprateur default retourne la valeur par dfaut du type spcifi. Il s'agit de la valeur quand une
variable de ce type n'est pas initialise (0 pour les nombres, null pour les types rfrences).
Exemple:
public int absolu(int? valeur)
{
if (valeur==null) return default(int);
else return (valeur<0) ? -valeur : valeur;
}
L'utilit de cet oprateur est plus vident avec l'utilisation de types gnriques.
[modifier]Obtenir
le type
L'oprateur typeof retourne une instance de la classe System.Type pour le type spcifi entre
parenthses.
Exemple:
Type t=typeof(int);
L'utilit de cet oprateur est plus vident avec l'utilisation de types gnriques.
Les tableaux
Un tableau regroupe plusieurs donnes du mme type dans un ensemble ordonn, index par un
entier. En C#, comme avec la plupart des langages de programmation modernes, le premier lment
porte l'index 0.
Sections
[masquer]
1 Dclaration d'un tableau
2 Allocation d'un tableau
3 Pr-initialisation
4 Accs aux lments
5 Taille d'un tableau
6 Tableaux multi-dimensionnels
d'un tableau
Les crochets ajouts la fin d'un type indique qu'il s'agit d'un tableau.
Exemple :
int[] entiers;
La variable entiers est un tableau de nombres entiers. Le nombre d'lments du tableau n'est pas
spcifi la dclaration, mais lors de l'allocation du tableau.
[modifier]Allocation
d'un tableau
Les tableaux font partie des types rfrences. Il n'est donc pas allou par dfaut (rfrence null).
L'allocation se fait en utilisant le mot cl new :
new type[taille]
Exemple :
int[] entiers = new int[10]; // un tableau de 10 entiers
Il est galement possible de l'allouer ailleurs que dans la dclaration :
int[] entiers;
...
entiers = new int[10]; // un tableau de 10 entiers
Une fois la place du tableau rserve en mmoire, celui-ci ne contient que des valeurs par dfaut,
c'est dire que chaque lment d'un tableau de numriques (entiers, rels, ...) vaut 0, pour un tableau
de bool chaque lment vaut false, et pour un tableau de rfrences (objet, interface, tableau)
chaque lment vaut null.
[modifier]Pr-initialisation
Il est galement possible de dfinir directement les valeurs que le tableau contient. Ces valeurs
doivent tre comprises entre des accolades et spares par une virgule. Le compilateur dtermine le
nombre d'lments allouer d'aprs la liste d'lments spcifie la suite de l'instruction d'allocation.
Exemples :
A la dclaration du tableau :
int[] entiers = new int[] { 10,15,20,25,30,35,40,45 };
Hors dclaration :
entiers = new int[] { 10,15,20,25,30,35,40,45 };

Seule la dclaration peut omettre l'instruction d'allocation du tableau avant les accolades :
int[] entiers = { 10,15,20,25,30,35,40,45 };
Dans ce cas, le compilateur alloue implicitement un tableau du mme type que la variable dclare,
pour le nombre d'lments placs entre les accolades.
[modifier]Accs
aux lments
L'accs (lecture et criture) aux lments du tableau se fait en utilisant le nom du tableau suivi des
crochets encadrant l'index de l'lment accd :
entiers[0] = 7;
entiers[1] = 13;
Console.WriteLine("1er entier = " + entiers[0] );
L'index spcifi est en fait une expression. Il est donc possible d'utiliser une variable comme index,
par exemple, pour parcourir les lments du tableau :
for(int i=0 ; i<2 ; i++)
Console.WriteLine("entier n" + i + " = " + entiers[ i ] );
[modifier]Taille
d'un tableau
L'attribut Length donne la taille du tableau. Ce qui est pratique pour le parcourir :
Console.WriteLine("Le tableau contient " + entiers.Length + " entiers :");
for(int i=0 ; i<entiers.Length ; i++) // i : index dans le tableau
Console.WriteLine(" ["+i+"] = " + entiers[i] );
Si l'index n'est pas ncessaire durant le parcours du tableau, il est plus simple d'utiliser foreach :
Console.WriteLine("Le tableau contient " + entiers.Length + " entiers :");
foreach(int n in entiers) // n : lment du tableau
Console.WriteLine(" " + n );
[modifier]Tableaux
multi-dimensionnels
Les tableaux vus jusqu' prsent taient des tableaux uni-dimensionnels : ils n'ont qu'une seule
dimension, c'est dire un seul index.
Certaines applications ncessitent des tableaux deux indices ou davantage. Par exemple, une
image est reprsente par un tableau de couleurs index par l'abscisse (x) et l'ordonne (y).
Un tableau multi-dimensionnel utilise la mme syntaxe, en sparant les indices par une virgule.
int[,] image = new int[ 32, 16 ];
// un tableau de 32*16 entiers, soit 512 entiers
image[1,5] = 0;
Un tableau de tableaux (appel jagged array ou tableau dchiquet) utilise la syntaxe des tableaux
uni-dimensionnels en utilisant un tableau comme type de base :
int[][] ensembles = new int[10][]; // un tableau de 10 tableaux d'entiers
ensembles[0] = new int[11];
// dont le premier contient 11 entiers
ensembles[1] = new int[] { 2, 3 }; // le deuxime : 2 entiers (2 et 3)
// ensembles[2] ensembles[9] valent null car non allous
ensembles[1][1] = 4; // remplace la valeur 3 par 4
Chacun des sous-tableaux doit tre allou sparemment, et rien n'oblige ce qu'ils aient tous la
mme dimension (d'o l'appellation de tableau dchiquet).
Il est galement possible de combiner les possibilits :
int[,][] donnees = new int[10,20][];
donnees[1,5] = new int[25];

donnees[1,5][10] = 12;
Les objets
Un objet est un type rfrence. Il s'agit d'une instance de classe.
[modifier]Le type object

La classe System.Object est quivalente au type object. Il s'agit de la classe de base de toutes
les autres classes.
L'auto-boxing/unboxing permet d'utiliser le type object pour n'importe quel type de valeur :
object obj;
obj = 10;
// int -> Int32 -> object
obj = "Une chane"; // string -> String -> object
[modifier]Crer un nouvel objet

Crer un nouvel objet est appel instancier une classe et utilise l'oprateur new :
classe variable=new classe(arguments...);
Cet oprateur effectue les oprations suivantes :
allocation d'une zone mmoire d'une taille suffisante pour accueillir les attributs dfinis dans
la classe spcifie,
initialisation des attributs leur valeur par dfaut (dfinie dans la classe ou 0 sinon),
appel au constructeur acceptant les arguments spcifis.
L'appel peut chouer pour plusieurs raisons :
la classe spcifie n'a pas pu tre charge,
l'espace mmoire libre est insuffisant,
une exception a t lance par le constructeur.
Dans tous les cas une exception est lance.
Les classes
La notion de classe est la base de la programmation oriente objet. Elle dfinit un type d'objet. Ce
type rassemble des variables (cres pour chaque objet et appeles attributs ) et des fonctions
(appeles dans ce cas mthodes ).
Ces attributs et mthodes sont les membres de la classe. Ils peuvent avoir chacun un niveau de
protection diffrent.
Sections
[masquer]
1 Dclarer une classe
1.1 Membres d'une classe
1.2 Membres statiques de classe et membres d'instance
1.3 Classe statique
1.4 Instance d'une classe
1.5 La rfrence nulle
2 Niveaux de protection
3 Constructeur
3.1 Exemple
3.2 Constructeur par dfaut
3.3 Constructeur statique
[modifier]Dclarer
une classe
La dclaration d'une classe utilise le mot cl class :

class nom_de_la_classe
{
}
Les membres sont dfinis l'intrieur des accolades.

Exemple :
class Fraction
{
int numerateur,
denominateur;
void multiplier(Fraction autre)
{
this.numerateur *= autre.numerateur;
this.denominateur *= autre.denominateur;
}
}
[modifier]Membres
d'une classe
Les membres d'une classe sont de diffrents types :
Les fonctions, appeles mthodes, traitent les donnes, appellent d'autres mthodes, retournent
ventuellement une valeur ;
Les variables, appeles attributs, stockent les donnes ;
Les proprits sont des mthodes spciales utilises comme des variables.
[modifier]Membres
statiques de classe et membres d'instance
Un membre statique de classe est un membre dclar avec le mot cl static. Il est dfinit une seule
fois en mmoire, et il n'est pas ncessaire de crer un nouvel objet pour qu'il soit cr et utilisable.
Un membre d'instance est dclar sans le mot cl static. Il n'est cr que pour chaque objet (une
instance) cr par l'oprateur new.
Exemple :
public class UnExemple
{
int numero; // Dfini pour chaque objet
static int numero_suivant; // Dfini pour la classe
}
Console.WriteLine("N suivant = " + UnExemple.numero_suivant );
Console.WriteLine("N = " + UnExemple.numero );
// Erreur de compilation, car la variable n'est pas dfinie pour la classe
UnExemple InstanceDUnExemple = new UnExemple();
Console.WriteLine("N = " + InstanceDUnExemple.numero );
[modifier]Classe statique
Une classe statique ne contient que des membres statiques, et ne peut tre instancie. Le mot
cl static prcde la dclaration de cette classe.
Exemple :
public static class UneClasseStatique
{
public static void Afficher(string message)
{
// ...
}
}
UneClasseStatique.Afficher("Un exemple de message");
[modifier]Instance d'une classe
L'instance d'une classe est aussi appele un objet. Une variable de ce type est un type rfrence,
c'est dire que la rfrence est nulle par dfaut. Il faut donc utiliser le mot cl new pour allouer une
instance de la classe.
Exemple :
UnExemple objetExemple; // par dfaut : null
// Equivaut
UnExemple objetExemple = null;
objetExemple = new UnExemple();
Le mot cl new est suivi du nom de la classe et d'une liste de paramtres entre parenthses. Il s'agit
en fait d'un appel au constructeur (abord plus loin dans ce chapitre) initialisant l'objet cr.
[modifier]La
rfrence nulle
Toute variable de type objet est en fait une rfrence initialise null par dfaut. Cette rfrence
peut tre utilise quel que soit le type d'objet.
Il est souvent ncessaire de tester si la rfrence est nulle avant d'accder un membre de l'objet
rfrenc. Si le test n'est pas fait et que la rfrence est nulle, une exception est leve.
[modifier]Niveaux
de protection
Le niveau de protection est spcifi par un mot cl plac avant la dclaration d'une classe ou d'un
membre de classe (attribut, mthode, proprit, ...) :
public
Accs autoris tous ;
private
Accs depuis la classe seulement ;
protected
Accs depuis la classe et ses sous-classes seulement ;
internal
Accs depuis l'assembly seulement.
Exemple :
public class Fraction
{
private int
numerateur,
denominateur;
public void multiplier(Fraction autre)
{ }
}
En gnral, les rgles de l'encapsulation sont les suivantes :
Toute mthode est publique, moins qu'elle ne soit destine tre

exclusivement appele dans la classe, auquel cas est peut tre prive ou
protge,
Les attributs sont privs. Si un accs est ncessaire, il faut ajouter des
mthodes d'accs (accesseurs), voire une proprit.
[modifier]Constructeur
Un constructeur est une mthode spciale portant le nom de la classe, ne
retournant aucune valeur, charge d'initialiser l'instance. Un constructeur peut
avoir des paramtres permettant de dfinir les valeurs initiales des attributs du
nouvel objet.
Une classe possde souvent plusieurs constructeurs. Chacun possdant une
liste d'arguments diffrente.
[modifier]Exemple
Pour initialiser une fraction :
{
private int
numerateur,
denominateur;
// Constructeur
public Fraction(int numerateur, int denominateur)
{
// this est utilis pour dsigner les attributs de
l'objet
// plutt que les paramtres
// recopie des paramtres :
this.numerateur = numerateur;
this.denominateur = denominateur;
}
public void multiplier(Fraction autre)
{ }
}
Utilisation :
Fraction estimation_pi = new Fraction( 355 , 113 );
[modifier]Constructeur par dfaut
Le constructeur par dfaut est celui qui n'a aucun paramtre. Si aucun
constructeur n'est dclar dans une classe, le compilateur cre un constructeur
par dfaut qui ne fait rien, laissant les attributs leur valeur par dfaut
(dpendant du type : 0 pour les numriques, null pour tous les autres).
En fait, ce constructeur par dfaut appelle le constructeur sans argument (qu'il
soit par dfaut ou explicitement implment) de la classe de base
(System.Object par dfaut). Voir le chapitre sur l'hritage de classe.
[modifier]Constructeur
statique
Il est possible d'excuter un code lors de la premire utilisation de la classe,

cette initialisation peut tre vue comme un constructeur statique
public class Fraction{
private static int valeur;
static Fraction(){
valeur = 1;
}
}
Les fonctions
Une fonction tant toujours dclare dans une classe, elles sont plutt appeles mthodes .
Sections
[masquer]
1 Dclarer une mthode
2 Appeler une mthode
3 Passage de paramtres une mthode
3.1 Passage par valeur
3.2 Paramtre out
3.3 Paramtre ref
3.3.1 C# 4.0 Mthode COM : ref optionnel
3.4 Nombre variable de paramtres
4 Surcharge de mthode
[modifier]Dclarer
une mthode
Une mthode possde un nom, une liste de paramtres, et un type de retour.

La syntaxe de dclaration est la suivante :
[accs] type_retour nom_mthode ( type argument, ... )

{
instructions
}
O accs est optionnel et dfinit le mode d'accs (public, priv ou protg), le type de mthode
(statique ou d'instance). Voir le chapitre sur les classes.
type_retour spcifie le type de la valeur retourne par la fonction. Ce type peut tre void (vide) pour
indiquer que la fonction ne retourne aucune valeur.
La fonction retourne une valeur en utilisant le mot cl return. L'instruction return interrompt
l'excution de la fonction, retourne la valeur de l'expression qui suit, et l'excution du code ayant
appel la fonction se poursuit.
La syntaxe est :
return expression;
Si la fonction ne retourne rien, l'instruction return n'est pas obligatoire, mais si elle est utilise,
aucune expression ne doit tre spcifie. Si la fonction ne retourne rien on appelera cette fonction une
procdure
Exemple :
// Fonction qui retourne la concatnation
// de la chane de caractres a la chane de caractres b
string Concatener(string a, string b)
{
return a+b;
}
[modifier]Appeler
une mthode
L'appel une mthode se fait en spcifiant son nom, suivi des arguments entre parenthses :
nom_methode ( expression, ... )
Si la fonction retourne une valeur, l'appel celle-ci peut tre utilis dans une expression.
Exemple :
string c = Concatener ( "abc" , "def" );
// c vaut "abcdef"
Dans cet exemple, la mthode appele est nomme Concatener car situe dans la mme classe
que l'appel. Cependant, toute mthode s'applique un objet. Celui-ci doit tre spcifi avant le nom
de la fonction, et spar par le caractre point ( . ). Par dfaut, il s'agit de l'objet this (objet courant).
[modifier]Passage
de paramtres une mthode
Les paramtres passs une mthode peuvent tre passs de trois manire diffrentes :
un paramtre en lecture seule (transmission d'information) : passage par valeur,
un paramtre rfrenant une variable pour y mettre une valeur de retour : paramtre out,
un paramtre rfrenant une variable pour transmettre une information et y mettre une valeur de
retour : paramtre ref.
[modifier]Passage
par valeur
Il s'agit d'un paramtre servant transmettre une information la mthode appele, comme dans les
exemples prcdents. Si la mthode modifie sa valeur, la modification est locale la fonction
uniquement. Un paramtre normal n'est prcd d'aucun mot-cl particulier.
Exemple :
private void methodeTest(int nombre)
{
Console.WriteLine("fonctionTest : le nombre vaut " + nombre);
nombre = 100;
Console.WriteLine("fonctionTest : le nombre vaut " + nombre);
}
private void testAppel()
{
int n = 5;
Console.WriteLine("testAppel : le nombre vaut " + n);
methodeTest(n); // Appel la mthode
// On peut passer une expression ou une constante
methodeTest( 25 + 5 ); // Appel la mthode
}
Ce programme affiche :
testAppel : le
fonctionTest :
fonctionTest :
testAppel : le
fonctionTest :
fonctionTest :
nombre vaut 5
le nombre vaut
le nombre vaut
nombre vaut 5
le nombre vaut
le nombre vaut
[modifier]Paramtre
out
5
100
30
100
Un paramtre out ne sert la fonction qu' retourner une valeur. L'argument transmis doit rfrencer
une variable ou un lment de tableau. Ce paramtre est prcd du mot-cl out la fois lors de sa
dclaration, et lors de l'appel la mthode.
La variable rfrence n'a pas besoin d'tre initialise auparavant. La fonction doit obligatoirement
affecter une valeur la variable rfrence.
Exemple :
private void methodeTest(out int resultat)
{
//Console.WriteLine("fonctionTest : le nombre vaut " + resultat);
resultat = 100;
//Console.WriteLine("fonctionTest : le nombre vaut " + resultat);
}
{
int n;
methodeTest(out n); // Appel la mthode
// On ne peut pas passer une expression ou une constante
//methodeTest( 25 + 5 ); // <- erreur de compilation
}
testAppel : le nombre vaut 100
[modifier]Paramtre
ref
Un paramtre ref est une combinaison des deux types de paramtres prcdents. L'argument
transmis doit rfrencer une variable ou un lment de tableau qui doit tre initialis auparavant. Ce
paramtre est prcd du mot-cl ref la fois lors de sa dclaration, et lors de l'appel la mthode.
La mthode n'est pas oblige de modifier la valeur contenue dans la variable rfrence.
Exemple :
private void methodeTest(ref int resultat)
{
Console.WriteLine("fonctionTest : le nombre vaut " + resultat);
resultat = 100;
Console.WriteLine("fonctionTest : le nombre vaut " + resultat);
}
{
int n = 5;
methodeTest(ref n); // Appel la mthode
// On ne peut pas passer une expression ou une constante
//methodeTest( 25 + 5 ); // <- erreur de compilation
}
testAppel : le
fonctionTest :
fonctionTest :
testAppel : le
nombre vaut 5
le nombre vaut 5
le nombre vaut 100
nombre vaut 100
[modifier]C# 4.0 Mthode COM : ref optionnel

L'appel une mthode d'interface COM utilisant un paramtre ref peut ne pas utiliser explicitement
de variable.
Exemple :
La mthode COM suivante :
void Increment(ref int x);
Peut tre appele sans le mot cl ref :
Increment(0);
Ce qui est quivalent :
int x = 0;
Increment(ref x);
Un paramtre ref est en gnral modifi par la mthode appele. Ne pas utilier le mot cl ref lors
de l'appel signifie que la nouvelle valeur retourne par la mthode est ignore.
[modifier]Nombre
variable de paramtres
Une mthode peut possder un nombre variable de paramtres, comme, par exemple, la mthode
statique Format de la classe String :
string message = String.Format("A={0} et B={1}", a, b);
Ce genre de mthode possde un nombre de paramtres obligatoires, comme une mthode normale,
suivis d'un nombre variable de paramtres (voire aucun). Ces paramtres en nombre variable sont en
fait transmis sous la forme d'un tableau.
Une telle mthode utilise le mot cl params pour le dernier paramtre qui doit tre un tableau.
Exemples de mthodes :
public string MessageDeLog(string format, params object[] parametres)
{
return "LOG: "+String.Format(format, parametres);
}
public double Moyenne(params double[] nombres)
{
double sum=0;
if (nombres.Length==0) return 0;
foreach(double d in nombres)
sum += d;
return sum / nombres.Length;
}
Pour le paramtre marqu params, il est possible de transmettre soit une liste d'argument, soit un
tableau contenant ces arguments.
Exemples d'appels :
double a = Moyenne(3.0, 2.0, 5.14, 8.22, 6.37);
// Equivaut :
double b = Moyenne( new double[]{ 3.0, 2.0, 5.14, 8.22, 6.37 } );
[modifier]Surcharge
de mthode
Une mthode peut tre surcharge (overload en anglais), c'est dire qu'il peut exister au sein de la
mme classe plusieurs mthodes portant le mme nom, condition qu'elles soient diffrenciables par
leur signature. La signature d'une mthode correspond aux types et nombre de paramtres accepts
par celle-ci.
Exemple :
public int Ajouter ( int valeur1, int valeur2 )
{
return valeur1 + valeur2;
}
public double Ajouter ( double valeur1, double valeur2 )
{
return valeur1 + valeur2;
}
Le compilateur dtermine la mthode appeler en fonction du type des arguments passs la
mthode.
Exemple :
Console.WriteLine("(entiers) 2 + 5 = " + Ajouter( 2, 5 ));
Console.WriteLine("(rels) 2.0 + 5.0 = " + Ajouter( 2.0, 5.0 ));
Le type de retour ne fait pas partie de la signature, car la valeur retourne par une mthode appele
peut tre ignore. Si deux mthodes portent le mme nom et ont la mme signature, le compilateur
gnre une erreur.
Exemple :
Ce code contient une erreur volontaire !
Les deux mthodes ont la mme signature.
public double Longueur ( string chaine )
{
return (double) chaine.Length;
}
public int Longueur ( string chaine )
{
return (int) chaine.Length;
}
Proprits et indexeurs
Sections
[masquer]
1 Les proprits
1.1 Syntaxe
1.2 Exemple
1.3 Noms rservs
2 Les indexeurs
2.1 Syntaxe
2.2 Exemple
[modifier]Les
proprits
Une proprit est une valeur qui peut tre lue ou modifie, comme une variable. Ces deux oprations
sont en fait ralises par les accesseurs get et set. Si l'un de ces deux accesseurs est manquant, la
proprit sera alors soit en lecture seule, soit en criture seule.
[modifier]Syntaxe
Type Nom_de_la_proprit
{
get // proprit lue
{
code retournant une valeur du Type spcifi
}
set // proprit modifie

{
code utilisant le paramtre prdfini "value"
}
}
Le code contenu dans chaque bloc est le mme que celui que l'on placerait pour implmenter les
mthodes suivantes :
Type getNom_de_la_proprit()
{
code retournant une valeur du Type spcifi
}
void setNom_de_la_proprit(Type value) // proprit modifie
{
code utilisant le paramtre prdfini "value"
}
[modifier]Exemple
private string _message;
public string Message
{
get
{
return _message;
}
set
{
_message = value;
}
}
Utilisation :
Message = "Test de la proprit" ; // <- accesseur set
Console.WriteLine( Message ); // <- accesseur get
Message += " et message ajout"; // <- accesseurs get et set
[modifier]Noms rservs
Depuis la version 2003 du compilateur, lorsqu'une proprit est cre, deux noms de mthodes sont
rservs pour les deux accesseurs :
type get_Nom_proprit()
void set_Nom_proprit(type value)
La classe ne peut donc avoir de mthodes portant l'une de ces deux signatures.
[modifier]Les
indexeurs
Un indexeur est une proprit spciale qui permet d'utiliser une instance de la classe comme
un tableau, en utilisant les crochets.
[modifier]Syntaxe
Type_lment this[ Type_index index ]
{
get // lment [index] lu
{
Code retournant une valeur du Type_lments spcifi
dont l'index est dans le paramtre index
}
set // lment [index] modifi
{
Code utilisant le paramtre prdfini "value"
pour le stocker l'index spcifi par le paramtre index
}
}
Type_lment
Type de chaque lment du tableau virtuel.
Type_index
Type de l'indice spcifi entre crochets.
index
Variable contenant la valeur de l'indice de l'lment lu ou modifi.
L'index peut avoir un autre type que int. C'est le cas des tables de hashage de
l'espace de nom System.Collections.
[modifier]Exemple
public class TableauVirtuel
{
public string this[int index]
{
// lecture seule car pas d'accesseur set
get
{
return "Elment"+index.ToString();
}
}
}
...
TableauVirtuel tab=new TableauVirtuel();
Console.WriteLine("tab[15] = " + tab[15] );
// affiche Elment15
Hritage de classes
Une classe peut hriter d'une autre, c'est dire possder les mmes mthodes et attributs que celle-ci
et en avoir des supplmentaires. Cette nouvelle classe est appele classe fille ou sous-classe .
Elle hrite d'une classe mre ou classe de base ou super-classe .
L'hritage entre deux classes traduit la relation est un type de . Par exemple, une automobile est
un type de vhicule. Elle possde la mme fonctionnalit de transport que n'importe quel vhicule. En
mme temps, une automobile a des fonctionnalits plus prcises qu'un vhicule : transport de
personnes principalement, capacit de transport limite, nombre de portes, puissance du moteur, ...
Ces spcificits de la sous-classe sont les seules qui ont besoin d'tre dfinies dans celle-ci. Les
autres fonctionnalits sont hrites de la super-classe.
Sections
[masquer]
1 Syntaxe
2 Constructeurs
3 Rfrence d'instance
4 Surcharge de mthodes et de proprits
4.1 Surcharge sans polymorphisme
4.2 Surcharge avec polymorphisme
4.3 Rsum
5 Classe sans hritire
[modifier]Syntaxe
La relation d'hritage est dfinie la dclaration de la classe par le symbole deux-points suivi du nom
de la super-classe.
Exemple de super-classe :
public class Vehicule
{
int roues, places, kilometrage;
public Vehicule()
{
}
}
Exemple de sous-classe :
public class Automobile : Vehicule
{
string couleur;
public Automobile()
{
}
}
[modifier]Constructeurs
Le constructeur de la sous-classe appelle toujours celui de la classe de base, implicitement ou
explicitement. Si rien n'est spcifi, le compilateur gnre un appel implicite au constructeur de la
classe de base ne comportant aucun paramtre. C'est pourquoi ce constructeur est nomm
constructeur par dfaut .
Si la classe de base ne possde aucun constructeur par dfaut, ou si un autre serait plus appropri, il
est possible de spcifier explicitement le constructeur appeler. Le mot-cl base dsigne la classe de
base.
Exemple :
{
int roues, places, kilometrage;
// Constructeur "protg" : l'accs est limit
// cette classe et aux sous-classes
protected Vehicule(int roues,int places)
{
this.roues = roues;
this.places = places;
}
}
{
string couleur;
public Automobile(string couleur)
: base( 4, 5 ) // appel au constructeur de Vehicule
// 4 roues et 5 places
{
this.couleur = couleur;
}
// Ajouter un constructeur par dfaut n'est pas obligatoire
// mais permet d'illustrer qu'il est possible d'appeler un
// autre constructeur de la mme classe
public Automobile()
: this( "indfinie" ) // couleur indfinie par dfaut
{
}
}
[modifier]Rfrence
d'instance
Une rfrence une instance de la sous-classe peut tre stocke par une rfrence du mme type :
Automobile voiture = new Automobile();
Il est galement possible d'utiliser une rfrence du type de la classe de base :
Vehicule voiture = new Automobile();
[modifier]Surcharge
de mthodes et de proprits
Dans cette section, la surcharge de proprits est similaire la surcharge de mthodes. Ce

paragraphe discutera de la surcharge de mthodes, mais tout ceci s'applique galement aux
proprits.
[modifier]Surcharge
sans polymorphisme
La surcharge d'une mthode consiste crer une mthode dans une sous-classe ayant le mme nom
et les mmes types d'arguments (la mme signature) qu'une mthode de la classe de base, afin de
modifier son comportement.
Exemple :
{
private int poids;
public Vehicule(int poids)
{ this.poids = poids; }
public string Description()
{
return "Vhicule de "+poids+" tonnes";
}
}
{
private string couleur;
public Automobile(int poids,string couleur)
: base(poids)
{ this.couleur = couleur; }
// mthode surcharge
public string Description()
{
return base.Description()+" de couleur "+couleur;
}
}
Cependant, le compilateur gnre un avertissement (warning CS0108) dans la classe drive. Il faut
spcifier que l'on surcharge une mthode, en utilisant le mot cl new :
{
: base(poids)
// mthode surcharge
public new string Description()
{
}
}
Utilisation :
Automobile voiture = new Automobile(3, "rouge");
Console.WriteLine( voiture.Description() );
// affiche : Vhicule de 3 tonnes de couleur rouge
Par contre, si on utilise une rfrence la classe de base Vehicule, la mthode appele sera celle de
la classe de base :
Vehicule vehicule = new Automobile(3, "rouge");
Console.WriteLine( vehicule.Description() );
// affiche : Vhicule de 3 tonnes
Une conversion de la rfrence vers la classe relle de l'objet permet d'appeler la mthode
surcharge :
Console.WriteLine( ((Automobile)vehicule).Description() );
Cet exemple n'utilise donc pas le polymorphisme, c'est dire que pour appeler la
mthode Description, le compilateur se base sur le type de la rfrence plutt que sur le type rel
de l'objet rfrenc.
[modifier]Surcharge
avec polymorphisme
Le polymorphisme permet d'utiliser le type rel de l'objet rfrenc plutt que le type de la rfrence
pour dterminer la mthode, la proprit ou l'indexeur utiliser. Pour cela, il faut utiliser le mot
clvirtual dans la dclaration de la mthode de la classe de base.
Exemple :
{
private int poids;
public Vehicule(int poids)

{ this.poids = poids; }
public virtual string Description()
{
return "Vhicule de "+poids+" tonnes";
}
}
Et il faut utiliser le mot cl override dans la classe drive :
{
: base(poids)
// mthode surcharge
public override string Description()
{
}
}
Utilisation :
Vehicule vehicule = new Automobile(3, "rouge");
Console.WriteLine( vehicule.Description() );
Si le mot cl new est utilis la place du mot cl override, le polymorphisme n'est pas effectif,
comme dans le paragraphe prcdent.
[modifier]Rsum
Pour rsumer :
Mthode de la classe de base
normale
Mthode surcharge
dans la
Classe drive
[modifier]Classe
virtual
Sans polymorphisme, Sans polymorphisme,

avertissement CS0108 avertissement CS0114
new
Sans polymorphisme
override erreur CS0506
sans hritire
Sans polymorphisme
Avec polymorphisme
Le mot-cl sealed empche la cration de classes drives. Cette fonctionnalit est galement utile
pour les classes ne dclarant que des membres statiques.
Syntaxe:
sealed class nom_classe
Exemple:
public sealed class Ferrari : Automobile
{
private int consommation;
public Ferrari(int litre_par_km)
: base(5100, "Rouge")
{ consommation = litre_par_km; }
}
Ce type de classe ne peut avoir de mthodes abstraites (abstract) ou de membres protgs
(protected) car aucune classe drive ne pourra tre cre pour les implmenter / y accder.
Classe abstraite
Une classe abstraite possde au moins une mthode abstraite ou une proprit abstraite, c'est dire
ne comportant aucune implmentation (pas de code). Une telle classe ne peut tre instancie avec
l'oprateur new. Il faut utiliser une sous-classe implmentant les mthodes abstraites de la classe de
base.
Sections
[masquer]
1 Syntaxe
2 Implmenter les mthodes abstraites
3 Proprits abstraites
4 Mode d'accs
[modifier]Syntaxe
Le mot cl abstract doit prcder la classe abstraite et toutes les mthodes abstraites.
Exemple :
// Classe abstraite grant un ensemble d'objets
public abstract class Ensemble
{
public bool AjouterSiNeContientPas(object o)
{
if ( ! Contient(o) )
Ajouter(o);
}
public bool RetirerSiContient(object o)
{
if ( Contient(o) )
Retirer(o);
}
// mthodes abstraites (sans implmentation) :
public abstract bool Contient(object o);
protected abstract void Ajouter(object o);
protected abstract void Retirer(object o);
}
[modifier]Implmenter
les mthodes abstraites
La classe implmentant les mthodes abstraites de la classe de base doit utiliser le mot
cl override, car les mthodes abstraites sont implicitement virtuelles galement :
public class EnsembleTableau : Ensemble
{
private object[] elements = new object[0];
public override bool Contient(object o)
{
// recherche de l'objet
for(int i = 0 ; i < elements.Length ; i++)
if (elements[i] == o) return true; // objet trouv
// fin de la boucle sans avoir trouv l'objet
return false;
}
protected override void Ajouter(object o)
{
// ...
}
protected override void Retirer(object o)
{
// ...
}
}
La classe peut ne pas implmenter toutes les mthodes abstraites de la classe de base. Dans ce cas
elle est galement abstraite, et laisse le soin ses sous-classes d'implmenter les mthodes
abstraites restantes.
[modifier]Proprits
abstraites
Il est galement possible de dclarer des proprits abstraites.

Exemple :
public abstract class Ensemble
{
public abstract int nombre { get; }
public abstract string nom { get; set; }
}
public class EnsembleTableau : Ensemble
{
private string nom_ensemble = null;
private object[] elements = new object[0];
public override int nombre
{
get { return elements.Count; }
}
public override string nom
{
get { return nom_ensemble ; }
set { nom_ensemble = value ; }
}
}
[modifier]Mode
d'accs
Puisque les mthodes et proprits abstraites doivent tre implmentes par les sous-classes, il n'est
pas possible de les dclarer avec le mot cl private, ou d'utiliser le mot cl sealed avec la classe.
De plus les mthodes et proprits abstraites ne peuvent tre statiques.
Les exceptions
Une exception est cre et lance quand une erreur survient. Elle se propage dans la pile d'appel de
la manire suivante : partir du moment o elle est lance, l'excution normale est interrompue, et un
gestionnaire d'exceptions est recherch dans le bloc d'instruction courant. S'il n'est pas trouv, la
recherche se poursuit dans le bloc englobant celui-ci, ou dfaut, dans le bloc de la fonction
appelante, et ainsi de suite... Si la recherche n'aboutit pas, une bote de dialogue signalant l'exception
est affiche.
Sections
[masquer]
1 Attraper une exception
2 Librer des ressources
3 Lancer une exception
4 Crer une classe d'exception
[modifier]Attraper
une exception
Un gestionnaire d'exception attrape une classe d'exception particulire et gre le cas d'erreur
correspondant. Ce gestionnaire encadre les instructions grer pouvant lancer une exception.
try
{
// Une exception peut tre lance
instructions
}
catch ( classe_d_exception variable )
{
// Grer l'erreur en fonction des dtails
// de l'erreur contenus dans la variable
instructions
}
...autres blocs catch...
finally
{
// Instructions toujours excutes
// exception lance ou non
instructions
}
Le bloc try est suivi d'un nombre quelconque de bloc catch (ventuellement aucun) attrapant
diffrents types d'exception, et ventuellement d'un bloc finally qui sera toujours excut quoi qu'il
se passe.
Exemple :
try
{
Console.Write("Entrez un nombre : ");
int n = int.Parse( Console.ReadLine() );
Console.WriteLine("
100/nombre = "+( 100/n ));
}
catch ( DivideByZeroException dbzex )
{
Console.Error.WriteLine(" Division par zro");
}
catch ( Exception ex )
{
Console.Error.WriteLine(
" Une autre exception a eu lieu : "+ex.Message);
}
finally
{
Console.WriteLine(
" Quel que soit le rsultat, ceci est affich");
}
[modifier]Librer
des ressources
Un bloc finally est utile pour librer des ressources la fin d'un traitement, qu'une erreur ait eu lieu
ou non.
Exemple :
Bitmap bm;
try
{
bm=new Bitmap(100,100);
...
}
finally
{
bm.Dispose(); // librer les ressources
}
Cependant, les classes implmentant l'interface IDisposable ont une mthode Dispose(), et
peuvent tre utilises avec le mot cl using :
using( Bitmap bm = new Bitmap(100,100) ) // <- objet IDisposable
{
...
} // <- mthode Dispose() appele automatiquement
[modifier]Lancer
une exception
En cas d'erreur dans une mthode d'un programme (arguments invalides, ...), il est possible de lancer
une exception en utilisant le mot cl throw.
throw objet_exception;
O objet_exception est une instance de la classe Exception ou de l'une de ses sous-classes.

En gnral, l'objet exception est allou en mme temps qu'il est lanc :
throw new classe_exception(arguments);
La pile d'appel est enregistre dans l'objet exception au moment o il est cr.
Dans un gestionnaire d'exceptions, il est possible de relancer l'exception attrape en utilisant
l'instruction throw sans argument. Ce qui est utile quand le gestionnaire ne gre que partiellement
l'erreur qui devra tre totalement traite par un autre gestionnaire d'exceptions.
Exemple :
try
{
Console.Write("Entrez un nombre : ");
int n = int.Parse( Console.ReadLine() );
Console.WriteLine(" 100/nombre = "+( 100/nombre ));
}
catch ( DivideByZeroException dbzex )
{
Console.Error.WriteLine(" Division par zro");
throw; // relance la mme exception
}
[modifier]Crer
une classe d'exception
Lancer une exception signale une erreur particulire. Si aucune classe d'exception ne convient ou
n'est suffisamment prcise, ou si l'exception doit comporter des informations supplmentaires, il est
possible de crer une nouvelle classe d'exception.
Pour cela, il faut driver la classe Exception ou l'une de ses sous-classes. Par convention, toutes
ces sous-classes ont un nom se terminant par Exception.
Exemple :
public class ErreurDeScriptException : Exception
{
// Attributs
private int ligne,colonne;
private string fichier;
// Proprits (en lecture seule)
public int Ligne { get { return ligne; } }
public int Colonne { get { return colonne; } }
public string Fichier { get { return fichier; } }
// Constructeur
public ErreurDeScriptException(
string message,
string fichier,
int ligne,
int colonne )
: base(message) // appel au constructeur de la classe Exception
{
this.fichier = fichier;
this.ligne = ligne;
this.colonne = colonne;
}
}
Ensuite, cette classe peut tre utilise comme n'importe quelle autre classe d'exception :
if ( arg==null )
throw new ErreurDeScriptException(
"Un argument est ncessaire", fichier_script, 10 , 5);
Surcharge des oprateurs

La surcharge des oprateurs permet d'utiliser les oprateurs sur d'autres types (des classes) que les
types simples.
Certains oprateurs ne sont pas surchargeables. Il s'agit des oprateurs en rouge dans le tableau du
chapitre Les oprateurs.
Sections
[masquer]
1 Syntaxe
2 Implmentation par paire
3 Oprateurs de conversions
3.1 Explicite/Implicite
[modifier]Syntaxe
L'oprateur surdfini doit toujours tre statique et public, sinon le compilateur gnre une erreur.
L'oprateur est dclar en utilisant le mot cl operator suivi de l'oprateur surdfini.
Exemple :
public class NombreComplexe
{
private double n_reel, n_imag;
public NombreComplexe() {}
public NombreComplexe(double r,double i)
{ this.n_reel = r; this.n_imag = i; }
public static NombreComplexe operator +
(NombreComplexe a,NombreComplexe b)
{
return new NombreComplexe
( a.n_reel + b.n_reel , a.n_imag + b.n_imag );
}
}
[modifier]Implmentation
par paire
La surdfinition de certains oprateurs exige galement la surdfinition d'un autre. Ces oprateurs
doivent donc tre surdfinis par paire.
Il s'agit des paires d'oprateurs suivantes :
operator < et operator >
operator <= et operator >=
operator == et operator !=
En gnral, l'un des deux peut tre dfini en fonction de l'autre :
operator < en fonction de operator >

public static bool operator < (NombreComplexe a,NombreComplexe b)
{
return b > a;
}
operator > en fonction de operator <

public static bool operator > (NombreComplexe a,NombreComplexe b)
{
return b < a;
}
operator <= en fonction de operator >=

public static bool operator <= (NombreComplexe a,NombreComplexe b)
{
return b >= a;
}
operator >= en fonction de operator <=

public static bool operator >= (NombreComplexe a,NombreComplexe b)
{
return b <= a;
}
operator == en fonction de operator !=

public static bool operator == (NombreComplexe a,NombreComplexe b)
{
return !( a != b );
}
operator != en fonction de operator ==

public static bool operator != (NombreComplexe a,NombreComplexe b)
{
return !( a == b );
}
[modifier]Oprateurs
de conversions
Les oprateurs de conversions sont dclars dans une classe C en ajoutant une mthode utilisant la
syntaxe suivante :
operator type_cible(type_source valeur)
o l'un des deux types est la classe C : convertir un objet de classe C vers type_cible ou un objet de
type type_source vers classe C.
Exemple:
{
private int numerateur, denominateur;
public Fraction(int n, int d)
{ this.numerateur = n; this.denominateur = d; }
public double GetValue()
{ return this.numerateur / this.denominateur; }
public static implicit operator double(Fraction f)
{
return f.GetValue();
}
public static implicit operator Fraction(int entier)
{
return new Fraction(entier, 1);
}
}
...
Fraction f=new Fraction(1,3);
double d = f; // -> 0.33333...
...
Fraction f;
f = 5; // -> 5 / 1
[modifier]Explicite/Implicite
L'oprateur de conversion doit tre dclar avec l'un des mots-cls implicit ou explicit pour
qu'il soit utilis respectivement implicitement ou explicitement.
Exemple:
{
private int numerateur, denominateur;
public Fraction(int n, int d)
{ this.numerateur = n; this.denominateur = d; }
public double GetValue()
{ return this.numerateur / this.denominateur; }
public static explicit operator Fraction(int entier)
{
return new Fraction(entier, 1);
}
}
...
Fraction f;
f = (Fraction)5; // conversion explicite -> 5 / 1

C Sharp

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

C Sharp

Transféré par

Droits d'auteur :

Formats disponibles

Sommaire

Les variables et les constantes

Les variables et les constantes

1.3 Porte d'une variable

1.4 Dure de vie d'une variable

1.5 Variable en lecture seule

2.2 Types des constantes

2.3 Porte et dure de vie d'une constante

la valeur par dfaut du type boolen (bool) est false,

int quantite = 50,

System.Console.WriteLine("Nombre = " + nombre); // la variable

de vie d'une variable

const double prix_unitaire_unique = 1.50 ;

et dure de vie d'une constante

Les types de base et les dclarations

Un type de base est un type simple valeur.

1 Liste des types de base

2 Syntaxe des chanes de caractres

5 Valeur par dfaut

des types de base

Boolen (vrai ou faux : true ou false) true

Caractre Unicode (16 bits)

Entier sign sur 8 bits (1 octet)

Entier non sign sur 8 bits (1 octet)

Entier sign sur 16 bits

Entier non sign sur 16 bits

Entier sign sur 32 bits

Entier non sign sur 32 bits

Entier sign sur 64 bits

Entier non sign sur 64 bits

Nombre virgule flottante sur 32 bits

double System.Double Nombre virgule flottante sur 64 bits

decimal System.Decimal Nombre virgule flottante sur 128 bits

des chanes de caractres

1 Dclaration d'un tableau

2 Allocation d'un tableau

4 Accs aux lments

5 Taille d'un tableau

entiers = new int[] { 10,15,20,25,30,35,40,45 };

donnees[1,5] = new int[25];

[modifier]Le type object

[modifier]Crer un nouvel objet

Cet oprateur effectue les oprations suivantes :

appel au constructeur acceptant les arguments spcifis.

L'appel peut chouer pour plusieurs raisons :

la classe spcifie n'a pas pu tre charge,

l'espace mmoire libre est insuffisant,

une exception a t lance par le constructeur.

Dans tous les cas une exception est lance.

1 Dclarer une classe

1.1 Membres d'une classe

1.2 Membres statiques de classe et membres d'instance

1.3 Classe statique

1.4 Instance d'une classe

1.5 La rfrence nulle

3.2 Constructeur par dfaut

3.3 Constructeur statique

La dclaration d'une classe utilise le mot cl class :

Les membres sont dfinis l'intrieur des accolades.

Les membres d'une classe sont de diffrents types :

Les variables, appeles attributs, stockent les donnes ;

statiques de classe et membres d'instance

Toute mthode est publique, moins qu'elle ne soit destine tre