Cours Visual C Sharp

8/3/2019 Cours Visual C Sharp

http://slidepdf.com/reader/full/cours-visual-c-sharp 1/195

Support de Cours

Visual C# 2.0

proposé par Nadia HADDOUCHE epse CHETTA



Part 1: Introduction àVisual C# et Visual

Studio 2005



Chapitre 1: Bienvenue àVisual C#



Quelle est la structure d’un programme C# ?

L’exécution du programme commence à Main( )

Le mot clé using fait référence aux ressources dans lalibrairie des classes de .NET Framework

Un programme est composé d’instructions

Les instructions sont séparées par des « ; »

Les { } sont utilisées pour grouper les instructions

using System;using System.Collections.Generic;using System.Text;

namespace TextHello {class Program {

static void Main(string[ ] args) {Console.WriteLine("Hello World");

}}

}



Comment formater le Code en C#

Utiliser l’indentation C# est case sensitive

Les espaces blancs sont ignorés

Une ligne de commentaire est indiquée par // Des lignes de commentaire sont limitées par /* et */using System;using System.Collections.Generic;using System.Text;

namespace TextHello {class Program {

static void Main(string[ ] args) {Console.WriteLine("Hello World");

}}

}



L’utilisation les noms d’espace : Namespaces

Déclarer un namespace

namespace CompanyName {namespace Sales {

public class Customer () { }}

}

// Ornamespace CompanyName.Sales { ... }

La déclaration using using System;using CompanyName.Sales;

Namespaces imbriqués

namespace CompanyName {public class Customer () { }

}



Chapitre 2: Utiliser lesvariables, les opérateurs

et les expressions



Les mots clé de C#



Qu’est un type prédéfini?

Les Types sont utilisés pour définir des variables Les Variables stockent différent types de données

Les types prédéfinis sont ceux définis par C# et le .NET

Framework Vous pouvez définir les votre

Les Variables doivent être définies avant de les utiliser

Utiliser la camelCase convention pour nommer lesvariables



Les types prédéfinis de C#



Comment déclarer et initialiser des variables

Déclaration Affecter un type

Affecter un nom

Terminer par un ;

int numberOfVisitors;

Initialisation Utiliser l’opérateur “=“

Affecter une valeur

Terminer par un ;

1

2

3

1

2

3

Affecter des valeurs litérales Ajouter un suffixe de type1

decimal deposit = 100M;

string bear;

string bear = "Grizzly";



Comment déclarer et initialiser des chaînes decaractères

Exemple de chaîne de caractère

Déclarer une chaîne entre guillemets

Utiliser un retour chariot

Utiliser des verbatim strings

Utiliser la codification de caractères Unicode

string s = "Hello World"; // Hello World

string s = "Hello\nWorld"; // une ligne est ajoutée

string s = @"Hello\n"; // Hello\n

string s = "\"Hello\""; // "Hello"

Le caractère “A” est représenté par “U+0041”



Comment créer et déclarer des Constantes

Déclarée en utilisant le mot clé const et un type Sa valeur est affectée au moment de la déclaration

const int earthRadius = 6378;//km

const long meanDistanceToSun = 149600000;//km

const double meanOrbitalVelocity = 29.79D;//km sec



Comment faire des conversions entre types

Implicite

Effectué par le compilateur sur des opérations qui netronquent pas l’information

Explicite

Où on demande explicitement au compilateur d’effectuer

une conversion qui peut perdre de l’information

int x = 123456; //int est un entier de 4 bytes

long y = x; //conversion implicite à un long

int x = 65537;short z = (short) x;// conversion explicit à un short, z == 1



Qu’est ce que les Expressions et les Opérateurs?

Les opérateurs sont des Symboles utilisés dans les Expressions

Opérateurs communs

• Incrémenter/décrémenter

• Arithmétique

• Relationnel

• Egalité

• Conditionnel• Affectation

Exemple

++ --

* / % + -

< > <= >=

== !=

&& || ?:= *= /= %= += -= <<=

>>= &= ^= |=



Comment déterminer l’ordre de priorité desopérateurs ?

Les expressions sont évaluées selon l’ordre de priorité des

opérateurs

Les parenthèses peuvent être utilisées pour contrôler l’ordred’évaluation

l’ordre de priorité des opérateurs est aussi déterminé par

associativité Les opérateurs binaires sont associatifs à gauche

L’affectation et les opérateurs conditionnels sont are associatifs àdroite

(10 + 20) / 5 le résultat est 610 + (20 / 5) le résultat est 14

10 + 20 / 5 le résultat est 14



Chapitre 3: Ecrire desméthodes



Déclarer d’une méthode

La syntaxe d’une méthode avec Microsoft Visual C# est :

returnType methodName ( parameterList ) {

// … le corps de la méthode

}

Exemple

int addValues(int leftHandSide, int rightHandSide) {

// ...

return leftHandSide + rightHandSide; }

void showResult(int answer) {

// ... le corps de la méthode

}



Appeler une méthode

Une méthode est appelée par son suivi d’une listed’argument.

result = addValues(39, 3); // à droite d’une affectation

showResult(addValues(39, 3)); // comme argument pour appeler une autre méthode.

Il faut respecter le type et l’ordre des arguments

addValues; // pas de parenthèsesaddValues(); // pas assez d’argumentsaddValues(39); // pas assez d’argumentsaddValues("39", "3"); // types erronés



Définir la portée locale

class Example {

void firstMethod() {

int myVar;

...}

void anotherMethod() {

myVar = 42; // error – variable not in scope

...}

}



Définir la portée dans une classe

class Example {

void firstMethod() {

myVar = 45;

...

}void anotherMethod() {

myVar = 42;

...

}

int myVar = 0;

}



Surcharger une méthode (Overload)

Surcharger une méthode permet de créer plusieursméthodes dans une classe qui ont le même nom maisavec des signatures différentes

static void Main(){Console.WriteLine("The answer is ");Console.WriteLine(42);

}



Chapitre 4 :les instructionsconditionnelles



Déclarer une variable booléenne

bool areYouReady;areYouReady = true;

Console.WriteLine(areYouReady); // Affichera True .



Les opérateurs d’égalité

Opérateurs

• ==

• !=

Signification

égale

différent

Exemple Résultat si age = 42

age == 100

age != 100

false

true



Les opérateurs relationnels

Opérateurs

• <

• <=• >

• >=

Signification

inférieur

inf ou égalsupérieur

sup ou égal

Exemple Résultat si age = 42

age < 21

age <= 16age > 18

age >= 30

false

truetrue

false



Les opérateurs conditionnels

Opérateurs

• &&

• ||

Signification

et

ou

Exemple

(percent >= 0) && (percent <= 100);

(percent >= 0) || (percent <= 100);



Comment et quand utiliser l’instruction if

if if ( sales > 10000 ) { bonus += .05 * sales;} if ( sales > 10000 ) {

bonus += .05 * sales;}

else {bonus = 0;

}

if else

if else if

if ( sales > 10000 ) { bonus += .05 * sales;

}else if ( sales > 5000 ) {

bonus = .01 * sales;}

else {bonus = 0;if ( priorBonus == 0 ) {

//ScheduleMeeting;}

}



Comment utiliser l’instruction switch

switch (day){

case 0 : dayName = "Sunday"; break;

case 1 : dayName = "Monday"; break;

case 2 : dayName = "Tuesday"; break;...

default : dayName = "Unknown"; break;

}



Quand utiliser l’instruction switch

Vous ne pouvez utiliser que des données de typesprimitifs, comme int ou string.

Les étiquettes doivent être des constantes, comme 42ou “42”.

Les étiquettes doivent être uniques.

Lorsque deux étiquettes impliquent le mêmecomportement, il est possible de les regrouper.

Case 1:Case 2: x = 20;

break;



Chapitre 5 :les instructions itératives



Overview

Comment utiliser une boucle for Comment utiliser une boucle while

Comment utiliser une boucle do

Suivre par étapes l’exécution d’une instructionitérative pour voir le changement de valeur desvariables



Utiliser les opérateurs d’affectation composés

Ne pas écrire

• variable = variable * number;

• variable = variable / number;• variable = variable % number;

• variable = variable + number;

• variable = variable - number;

Écrire

• variable *= variable;

• variable /= variable;• variable %= variable;

• variable += variable;

• variable -= variable;



Comment utiliser une boucle while

Un test est effectué au début de la boucle, si le test estFalse, la boucle n’est jamais exécutée

La boucle s’exécute jusqu’à ce que la conditiondevienne fausse

continue, break

bool readingFile;

// . . .

while ( readingFile == true ) {GetNextLine();

}



Comment utiliser une boucle for

L’utiliser lorsque le nombre d’itérations à exécuter estconnu

for (int i = 0; i < 10; i++) {

Console.WriteLine("i = {0}",i);

}

for ( int j = 100; j > 0; j -= 10 ) {

Console.WriteLine("j = {0}", j);

}

for (initialiseur; condition; itération {

instructions;

}

Exemple



Comment utiliser une boucle for (suite)

for (int i = 0; ;i++) {

Console.WriteLine("somebody stop me!");

}

Exemples

int i = 0;for (; i != 10; ) {

Console.WriteLine(i); i++;}

for (int i = 0, j = 10; i <= j; i++, j--) {...

} //multiple initialisations//multiple mises à jour //une seule expression booléenne

••



La portée d’une instruction for

for (int i = 0; i != 10; i++) {...

}Console.WriteLine(i); // erreur de compilation

Exemples

for (int i = 0; i != 10; i++) {...

}for (int i = 0; i != 20; i += 2) {...} // OK



Comment utiliser une boucle do

Exécuter la boucle puis effectuer le test. Si le résultat estTrue, la boucle se répète jusqu’à ce que l’expressiondevienne False.

do {// instructions qui s’exécuteront au moins

// une fois} while (test est true);

int i = 1;do {Console.WriteLine ("{0}", i++);

} while (i <= 10);

Exemple



Chapitre 6:Gérer les erreurs et les

exceptions



Comment gérer les Exception

La syntaxe pour gérer les exceptions

try {// code suspect

}catch {// gérer les exceptions

}finally {

// toujours exécuter}



Comment gérer les Exception

try {int leftHandSide = Int32.Parse(leftHandSideOperand.Text);int rightHandSide = Int32.Parse(rightHandSideOperand.Text);int answer = doCalculation(leftHandSide, rightHandSide);

result.Text = answer.ToString();}catch (FormatException fEx) {

// gérer l’exception

...

}

Exemple



Utiliser plusieurs catch

try {int leftHandSide = Int32.Parse(leftHandSideOperand.Text);int rightHandSide = Int32.Parse(rightHandSideOperand.Text);int answer = doCalculation(leftHandSide, rightHandSide);result.Text = answer.ToString();

}catch (FormatException fEx) {

//...}catch (OverflowException oEx) {

//...}

La première exception qui correspond au problème estexécutée : l’ordre des catch est important

Exemple



Utiliser plusieurs exceptions

Les exceptions sont regroupées en familles et reliées

de façon hiérarchique par la relation d’héritage

try {int leftHandSide = Int32.Parse(leftHandSideOperand.Text);int rightHandSide = Int32.Parse(rightHandSideOperand.Text);

int answer = doCalculation(leftHandSide, rightHandSide);result.Text = answer.ToString();

}catch (Exception ex) {

//...

} // ceci est une exception générale



Gérer les débordements de capacité pour les int

Int32.MinValue et Int32.MaxValue permettent deconnaître les bornes d’un int.

C# ne génère pas d’exceptions en cas de débordementde capacité d’un int (valeur erronée).



Utiliser Checked et Unchecked pour les int

Il est possible d’activer ou de désactiver overflowchecking dans Visual Studio 2005.

Dans le menu Project, cliquer sur LeProjet Properties.

Dans la dialog box project properties, cliquer sur l’onglet Build.

Cliquer sur le bouton Advanced.

Dans la dialog box Advanced Build Settings, cocher ou

décocher “Check for arithmetic overflow/underflow”.



Utiliser Checked et Unchecked pour les int

Il est possible de vérifier le débordement d’un int int number = Int32.MaxValue;

checked {

int willThrow = number++;

Console.WriteLine("this won't be reached");}

int number = Int32.MaxValue;

checked {

int willThrow = number++;Console.WriteLine("this won't be reached");

}



Ecrire des expressions checked

int wontThrow = unchecked(Int32.MaxValue + 1); int willThrow = checked(Int32.MaxValue + 1);



Déclencher des Exceptions

Utiliser le mot clé Throw Types d’Exception

Les classes d’ exceptions prédéfinies dans le commonlanguage runtime

Exemple: ArithmeticException, FileNotFoundException

Les exceptions définies par l’utilisateur

é



Déclencher des Exceptions

public static string monthName(int month) {switch (month) {

case 1 : return "January";case 2 : return "February";...

case 12 : return "December";default : throw new ArgumentOutOfRangeException("Bad month");

}}

Exemple

Utili l bl fi ll



Utiliser le bloc finally

TextReader reader = null;try {

reader = src.OpenText();string line;while ((line = reader.ReadLine()) != null) {

source.Text += line + "\n";}

}finally {

if (reader != null) {

reader.Close();}

}



Part II : Comprendre lelangage C#



Chapitre 7 : Créer desclasses et des objets

Q t l l t l bj t ?



Que sont les classes et les objets?

Classe: est comme un négatif pour des objets

Contient des attributs et des méthodes

Objets:

instances d’une classe

Créés en utilisant le motclé new

Impliquent des actions

Objet

kitchen

Living Room

Bath Office

DiningRoom

FamilyRoom

Covered Porch

Classe

C t défi i l t é d bj t



Comment définir une classe et créer des objets

public class Customer {public string name;public decimal creditLimit;public uint customerID;

}

Comment définir une classe

Comment instancier une classe : un objet

Customer nextCustomer = new Customer();

Comment accéder à un attribut de la classe

nextCustomer.name = "Suzan Fine";

L t i XML d d



Le commentaire XML du code

Trois slashes (///) avant la déclaration d’une méthode,insèrent des commentaires XML

Mettre un point juste après le nom d’un objet afficheun pop-up menu pour accéder aux membres de laclasse de l’objet.

Défi i l’ ibilité t l té



Définir l’accessibilité et la portée

Les modificateurs d’accès sont utilisés pour définir leniveau d’accessibilité aux membres d’une classe

Déclaration Définition

publicAccès illimité.

private Accès limité aux méthodes de la classe.

internal Accès limité au programme.

protected Accès limité aux méthodes de la classe et deses classes dérivées

protectedinternal

Accès limité aux méthodes de la classe, desclasses dérivées ou des membres du pgme

C ti



Conventions

Les identificateurs qui sont public commencent par

une majuscule. C’est la PascalCase notation Les identificateurs qui ne sont pas public commencent

par une minuscule. C’est la camelCase notation.

La seule exception à cette règle : une classe peutcommencer par une majuscule et ses constructeursdoivent avoir le même nom que la classe. Dans ce cas,un constructeur qui est private doit commencer par une majuscule.

Initialiser un objet



Initialiser un objet

public class Lion {public Lion() {

Console.WriteLine("Constructing Lion");}

}

Un constructeur d’Instances est une méthode spéciale

qui implémente les actions requises pour initialiser unobjet

Il a le même nom que la classe

Le constructeur par défaut ne prend pas de paramètres

Readonly Utilisée pour affecter une valeur à une variable dans le

constructeur

Surcharger un Constructeur



Surcharger un Constructeur

Créer plusieurs constructeurs qui ont le même nom

mais qui ont des signatures différentes Spécifier un initialiseur avec this

public class Lion {private string name;

private int age;

public Lion() : this( "unknown", 0 ) {Console.WriteLine("Default: {0}", name);

}public Lion( string theName, int theAge ) {

name = theName;age = theAge;Console.WriteLine("Specified: {0}", name);

}}

Les classes partielles



Les classes partielles

C# 2.0 permet de diviser le code source d’une classe

en plusieurs fichiers. Il est possible d’organiser la définition d’une grande

classe en de petits morceaux plus faciles à gérer.

Utiliser le mot clé partial

Pourquoi utiliser les membres de classe Static ?



Pourquoi utiliser les membres de classe Static ?

double d = m.Sqrt(42.24);

class Math{

public static double Sqrt(double d) { ... }...

}

class Circle{

public Circle(){

radius = 0.0;

NumCircles++;}

...private double radius;public static int NumCircles = 0;

}

Utiliser les membres de classe Static



Utiliser les membres de classe Static

Membre Static

Appartient à la classe

Initialisé avant la création d’une instance de la classe

Partagé par toutes les instances de la classe

Ne peut pas être préfixé par this

class Lion {public static string family = "felidae";

}...// un objet Lion n’a pas été créé dans ce code Console.WriteLine( "Family: {0}", Lion.family );

Initialiser une Classe



Initialiser une Classe

Constructeur Static Sera exécuté au plus une fois

Est exécuté avant que le premier objet de cette classene soit créé

N’a pas de paramètres (constructeur par défaut)

Ne prend pas de modificateurs d’accès

Est utilisé pour initialiser une classe

Les classes static



Les classes static

Une classe static ne contient que des membres static. Le but d’une classe static est d’être une conteneur

pour un ensemble de champs et de méthodes.



Chapitre 8 :Comprendre les valeurs

et références

Les value types et les reference types ?



Les value types et les reference types ?

Value Type

Contient directementdes données

Stocké dans la pile

Doit être initialisé

Doit être non null

int est un value type

int i;i = 42; CostObject c;

• 42

Reference Type

Contient une référence à ladonnées

Stocké dans la heap

Déclaré en utilisant new

.NET garbage collector s’occupe de la destruction

class est un reference type

42i c

Copier des variables int et des objets



Copier des variables int et des objets

Passer des paramètres à une méthode



Passer des paramètres à une méthode

class Lion {private int weight;public void SetWeight(int newWeight) {

weight = newWeight;}

}. . .

Lion bigLion = new Lion();

int bigLionWeight = 250;bigLion.SetWeight( bigLionWeight );

Passage par valeur

Passer des Paramètres par référence



Passer des Paramètres par référence

Utiliser le mot clé ref

Affectation définie: Les paramètres passées doiventêtre définis. Utiliser le mot clé out

Permet d’initialiser une variable dans une méthode

public void GetAddress(ref int number,ref string street) {number = this.number;street = this.street;

}

. . .int sNumber = 0; string streetName = null;zoo.GetAddress( ref sNumber, ref streetName );// sNumber et streetName ont de nouvellesvaleurs

Comment la mémoire est organisée



Comment la mémoire est organisée

La mémoire est divisée en deux parties: stack et heap. Les value types sont créés dans la stack.

Les reference types (objects) sont créés dans le heap.

La classe System Object



La classe System.Object

Toutes les classes héritent de la classe System.Object .

Il est possible d’utiliser System.Object pour créer unevariable qui fait référence à n’importe quel referencetype .

Utiliser object plutôt que System.Object .

Boxing



Boxing

Une variable de type object peut également faire

référence à un value type .

Modifier la variable i ne modifie pas la variable o.

unboxing



unboxing

int i = 42;

object o = i;

i = (int)o;

Unboxing (suite)



Unboxing (suite)

Le type spécifié lors du unboxing cast doit exactement

correspondre au type actuellement du box.



Chapitre 9: Créer des

Value Types avec desEnumerations et des

Structs



Afficher des variables



Afficher des variables

Season colorful = Season.Fall;Console.WriteLine(colorful); // Affiche 'Fall'

string name = colorful.ToString();Console.WriteLine(name); // Affiche aussi 'Fall'

Season colorful = Season.Fall;Console.WriteLine((int) colorful); // Affiche 2

enum Season { Spring, Summer, Fall, Winter}

Utiliser les types énumérations



Utiliser les types énumérations

Affecter des valeurs aux éléments de l’Énumération

Affecter un type sous-jacent aux éléments del’Énumération

enum Season { Spring = 1, Summer, Fall, Winter }

enum Season { Spring, Summer, Fall, Autumn = Fall, Winter }

enum Season : short { Spring, Summer, Fall, Winter }

Le type Structure



Le type Structure

Une structure peut avoir des propres champs,

méthodes, et constructeurs comme une a classe, maiselle un value type et non un reference type

Une structure est stockée dans le stack

Les types int, long, et float, sont des alias pour les

structures System.Int32, System.Int64, et System.Single

Il n’est pas possible de déclarer un constructeur par défaut car le compilateur le génère automatiquement siun autre constructeur n’a pas été défini.

Le constructeur par défaut initialisera les champs de lastructure à 0, false, ou null

Structure ou classe



Structure ou classe

StructureSystem.UInt16Ushort

StructureSystem.UInt64Ulong

StructureSystem.UInt32Uint

ClassSystem.StringString

StructureSystem.Int16Short

StructureSystem.SByteSbyte

ClassSystem.ObjectObject

StructureSystem.Int64Long

StructureSystem.Int32Int

StructureSystem.SingleFloat

StructureSystem.DoubleDouble

StructureSystem.Decimaldecimal

StructureSystem.Bytebyte

StructureSystem.Booleanbool

Class or structureType equivalentKeyword

StructureSystem.UInt16Ushort

StructureSystem.UInt64Ulong

StructureSystem.UInt32Uint

ClassSystem.StringString

StructureSystem.Int16Short

StructureSystem.SByteSbyte

ClassSystem.ObjectObject

StructureSystem.Int64Long

StructureSystem.Int32Int

StructureSystem.SingleFloat

StructureSystem.DoubleDouble

StructureSystem.Decimaldecimal

StructureSystem.Bytebyte

StructureSystem.Booleanbool

Class or structureType equivalentKeyword

Définir un type Structure



yp S

struct Time {public Time(int hh, int mm, int ss) {

hours = hh % 24;minutes = mm % 60;

seconds = ss % 60;}public int Hours() {

return hours;}...private int hours, minutes, seconds;

}

La différence entre structure et classe



struct Time {public Time() {

...} // erreur de compilation...

}

struct Time {public Time(int hh, int mm){hours = hh;minutes = mm;

} // erreur de compilation : seconds pas initialisée...private int hours, minutes, seconds;}

struct Time {...private int hours = 0; // erreur de compilationprivate int minutes;private int seconds;

}

Déclarer une variable Structure



struct Time {int hours, minutes, seconds;}

class Example {public void Method(Time parameter) {

Time localVariable;

...}private Time currentTime;

}

L’initialisation d’une structure



struct Time {public Time(int hh, int mm){

hours = hh;minutes = mm;seconds = 0;

}...private int hours, minutes, seconds;}

Copier une variable structure



p

Time now;Time copy = now; // compile time error: now unassigned



Chapitre 10:

Utiliser Array etCollection

Qu’est ce qu’un Array?



q y

Une structure de données qui contient un nombre devariables appelées array elements.

Tous les array elements doivent être de même type

Un Array est zero indexed

Un Array est un objet, c’est donc un reference type Un Array peut être :

Single-dimensional

Multidimensional

Jagged, un array dont les éléments sont des array

Déclarer et instantier un Array



y

Déclarer un array en ajoutant deux crochets après le

type de ses éléments

Instantier un array int[ ] numbers = new int[5];

Créer un array de type Object

object [ ] animals = new object [100];

Créer un array bi-dimensionnel

int[,] table = new int[4,6];

int[] MyIntegerArray;

Déclarer et instantier un Array (suite)



y ( )

Initialiser et Accéder aux Array Members



Initialiser un array

Accéder aux array members

int[] numbers = new int[10] {10, 9, 8, 7, 6,5, 4, 3, 2, 1, 0};

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2,1, 0};

string[] animal = {"Mouse", "Cat", "Lion"};animal[1]= "Elephant";

string someAnimal = animal[2];

Parcourir les éléments d’un Array en utilisant foreach



Utiliser foreach permet de répéter les instructions pour

chaque élément du array

ou

int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};

foreach (int i in numbers) {

Console.WriteLine(i);

}

int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};

for (int ndex = 0; index != numbers; index++) {

int i = numbers[index];

Console.WriteLine(i);

}

Quand ne pas utiliser foreach



foreach parcourt tous les éléments du array, pour parcourir une partie seulement utiliser l’instruction for.

foreach parcourt le array de l’index 0 vers l’indexLength – 1. Pour le parcours inverse utiliser l’instruction for.

Si le corps de la boucle a besoin de connaître l’indexd’un élément plutôt que sa valeur, utiliser l’instructionfor.





La classe ArrayList



ArrayList n’a pas la taille fixe; elle peut grandir aubesoin

Utiliser Add pour ajouter un object à la fin de laArrayList

Utiliser insert pour ajouter un object à une positiondans la ArrayList

Utiliser remove pour supprimer un object de laArrayList

Utiliser[] pour accéder aux éléments de la ArrayList

Utiliser Clear pour supprimer tous les éléments

Exemple



ArrayList numbers = new ArrayList();

foreach (int number in new int[12]{10,9,8,7,7,6,5,10,4,3,2,1}) {

numbers.Add(number);

}

// Supprimer le 1er élément dont la valeur est 7

numbers.Remove(7);

// Supprimer le 7ème élément (10) numbers.RemoveAt(6);

// Afficher les 10 éléments restants avec for

for (int i = 0; i != numbers.Count; i++) {

int number = (int)numbers[i]; //besoin d’un cast

Console.WriteLine(number);

}

// Afficher les 10 éléments restants avec foreach

foreach (int number in numbers){

Console.WriteLine(number); //pas besoin d’un cast

}

Les classes Queue et Stack



Queues: first-in, first-out Enqueue place les objets dans la queue

Dequeue supprime les objets de la queue

Stacks: last-in, first-out Push place les objets dans la stack

Pop supprime les objets de la stack

Exemple de la classe Queue



Queue numbers = new Queue();

// Remplir la queueforeach (int nbr in new int[4]{9, 3, 7, 2}) {

numbers.Enqueue(nbr);

Console.WriteLine(nbr + " a rejoint la queue " );

}

// Afficher les éléments de la queue

foreach (int number in numbers) {

Console.WriteLine(number);

}

// Vider la queue

while (numbers.Count != 0) {

int number = (int)numbers.Dequeue();

Console.WriteLine(number + " a quitté la queue");

}



La classe HashTable



Une hashtable est une structure de données qui associe une

clé avec un object, pour une recherche rapide Une SortedList est une hashtable dont les clés sont triées

Book techBook = new Book("Inside C#", 0735612889);// ...public Hashtable bookList;//

bookList.Add(0735612889, techBook);// Book b = (Book) bookList[0735612889];// le titre de b est "Inside C#"

ObjectKey

Exemple de la classe Hashtable



Hashtable ages = new Hashtable();// Remplir la Hashtable

ages["John"] = 41;

ages["Diana"] = 42;

ages["James"] = 13;

ages["Francesca"] = 11;// Parcourir la Hashtable

foreach (DictionaryEntry element in ages) {

string name = (string)element.Key;

int age = (int)element.Value;

Console.WriteLine("Name: {0}, Age: {1}", name, age);}





Chapitre 11 :Parameter Arrays

Utiliser un Array comme paramètres d’une Méthode



class Util{

public static int Min(int[] paramList){

if (paramList == null || paramList.Length == 0){

throw new ArgumentException("Util.Min");}int currentMin = paramList [0];foreach (int i in paramList)

{ if (i < currentMin){

currentMin = i;}

}return currentMin;

}

}

...int[] array = new int[3];array[0] = first;array[1] = second;array[2] = third;...

int min = Util.Min(array);



A ne pas faire



params ne peut être utilisée que pour des arrays d’une dimension.

Une méthode ne peut être surchargée sur la base de params seulement.

Il est interdit d’utiliser ref ou out pour des params arrays.

Un params array doit être le dernier paramètre.

Le compilateur détecte et rejette les surcharges potentiellementambiguës.

Une méthode non-params est toujours plus prioritaire sur une méthodeparams : Lorsque Min est appelée avec 2 paramètres, c’est la 1ère qui estexécutée

public static int Min(params int[,] table)

public static int Min(int[] paramList)public static int Min(params int[] paramList)

public static int Min(ref params int[] paramList)

public static int Min(out params int[] paramList)

public static int Min(params int[] paramList, int i)

public static int Min(params int[] paramList)

public static int Min(int, params int[] paramList)

public static int Min(int leftHandSide, int rightHandSide)public static int Min(params int[] paramList)





Chapitre 12 : L’héritage





L’héritage



L’héritage spécifie unerelation « est une sorte de/ is a kind of »

Les classes dérivées

héritent les propriétés etles méthode de la classede base, permettant ainsila réutilisation du code

Les classes dérivéesdeviennent plusspécialisées

Classe de base

Classes dérivées

Animal

Elephant Cat



Appeler le constructeur de base à partir de la classedérivée



Le mot clé base est utilisé par classe dérivée pour appeler le non-default constructor de la classe de base

public class Animal {public Animal(GenderType gender) {

// . . .

Console.WriteLine("Constructing Animal");}

}

public class Elephant : Animal {public Elephant(GenderType gender): base(gender) {

//Elephant codeConsole.WriteLine("Constructing Elephant");

}}



Les méthodes new



Le mot clé new permet de supprimer le warning seulement

class Token{

...

public string Name() { ... }}

class IdentifierToken : Token{

...

new public string Name() { ... }}

Polymorphisme



ObjetsAnimal

Elephant

Cat

Mouse

Comportement

Mange l’herbe

Mange la souris

Mange le fromage

MéthodeAppelée

Eat ()

Eat ()

Eat ()

Les méthodes Virtual



public class Animal {public virtual void Eat() {

Console.WriteLine("Eat something");

}

}

public class Cat : Animal {

public override void Eat() {

Console.WriteLine("Eat small animals");

}

}

Les méthodes Virtual (suite)



Les méthodes Virtual sont utilisées pour définir lesméthodes des classes de bases qui peuvent êtreredéfinies dans les classes dérivées

Classe de Base

Animal

Méthode Virtual

Eat ()

Classe dérivée

Cat

Méthode Override

Eat ()

Eat MouseEat Something

RésultatRésultat

Exemple



class Mammal{

public virtual string GetTypeName(){return "This is a mammal";

}}

class Horse : Mammal{

public override string GetTypeName(){

return "This is a horse";}

}

class Whale : Mammal{

public override string GetTypeName ()

{return "This is a whale";

}}

class Kangaroo : Mammal{

...

}

Mammal m;Horse h = new Horse();Whale w = new Whale();Kangaroo k = new Kangaroo();

m = h;Console.WriteLine(m.GetTypeName());m = w;Console.WriteLine(m.GetTypeName());m = k;Console.WriteLine(m.GetTypeName());

Comment utiliser les membres de la classe de basepar la classe dérivée



Le mot clé base est utilisé pour appeler une méthodedans la classe de base à partir de la classe dérivée

public class Cat : Animal {

public override void Eat() {

base.Eat();

Console.WriteLine("Eat small animals");

}

}

Quelques règles pour les méthodes virtual



Il est pas possible de déclarer virtual ou override une

méthode private. Les deux méthodes doivent être identiques (même

signature).

Les deux méthodes doivent avoir le même accès

(public, public par exemple). On ne peut override qu’une méthode virtual.

Si la classe dérivée n’est pas override, elle ne redéfiniepas la méthode de la classe de base.

Une méthode override est implicitement virtual et doncpeut être overridden. Il n’est pas permis de déclarer virtual une méthode override.



Qu’est ce qu’une Interface?



Une interface:

Un reference type qui défini un contrat

Spécifie les membres qui doivent être fournis par lesclasses ou interfaces qui implémentent l’interface

Peut contenir des méthodes, des propriétés, desindexers et des évènements

Ses membres ne sont pas implémentés

Peut hériter de zéro ou plusieurs interfaces

Les restrictions sur les interfaces



Une interface:

Ne contient pas de champs, même static.

Ne contient pas de constructeurs.

Ne contient pas de destructeurs.

Ne contient pas des access modifiers. Toutes lesméthodes sont implicitement public.

Ne contient pas les enums, structs, classes, interfaces,or delegates.

Ne peut être héritée à partir d’une classe ou d’unestructure.



Travailler avec des objets qui implémentent desinterfaces



is

as

if ( anAnimal is ICarnivore ) {ICarnivore meatEater = (ICarnivore) anAnimal;Animal prey = meatEater.Hunt();meatEater.Eat( prey );

}

ICarnivore meatEater = anAnimal as ICarnivore;if ( meatEater != null ) {

Animal prey = meatEater.Hunt();meatEater.Eat( prey );

}

// is et as avec un objetif ( prey is Antelope ) { ... }

Référencer une classe à travers son interface



IdentifierToken it = new IdentifierToken();IToken iTok = it; // légal

void Process(Itoken iTok)

{...

}



Les Interfaces et le .NET Framework



Permettent à vos objets de se comporter comme les objets

du .NET Framework Exemple: Interfaces utilisées par les classes Collection

ICollection, IComparer, IDictionary, IDictionary Enumerator,IEnumerable, IEnumerator, IHashCodeProvider, IList

public class Zoo : IEnumerable {. . .public IEnumerator GetEnumerator() {

return (IEnumerator)new ZooEnumerator(this );}

Les classes et les méthodes abstract



Une classe abstract class est une classe de base générique

Contient une méthode abstract qui doit être implémentée par uneclasse dérivée

Une méthode abstract n’est pas imlémentée dans la classe de base

Elle peut contenir des membres non-abstract

Elle ne peut être instanciée

public abstract class Animal {public abstract void Eat();

public abstract Group PhylogenicGroup { get; }

}

Les classes et les méthodes Sealed



Les classes abstract

Il est impossible de créer une classe dérivée à partir d’une classe sealed

Une classe sealed ne contient pas de méthodes virtual

Les méthodes sealed

Une méthode sealed ne peut être overidden dans la

classe dérivée. Une méthode doit être override pour lui attribuer le

qualificatif sealed : la méthode sera déclarée sealedoverride.

public sealed class MyClass {

// class members}

interface, virtual, override, et sealed



Une interface introduit le nom d’une méthode.

Une méthode virtual est la première implémentationd’une méthode.

Une méthode override est une autre implémentationd’une méthode.

Une méthode sealed est la dernière implémentationd’une méthode.

Résumé



Mot clé Interface Classe Abstract Classe Classe sealed struct Abstract

no

yes

no

no

no

New yes* yes yes yes no† override no yes yes yes no‡ private no yes yes yes yes protected no yes yes yes no** public no yes yes yes yes sealed no yes yes yes no virtual no yes yes no no *Une interface peut étendre une autre interface et introduire une nouvelle

méthode avec la même signature.

†Une struct derive implicitement de System.Object, qui contient desméthodes que la struct peut cacher.

‡ Une struct dérive implicitement de System.Object, qui ne contient pasde méthodes virtual.

**Une struct est implicitement sealed.



Chapitre 13:

Garbage Collection etResource Management







Resource Management



Certaines ressources sont si précieuse qu’il est

nécessaire de les libérer le plutôt possible. Ces classes possèdent des méthodes disposal pour

les libérer.

TextReader reader = new StreamReader(filename);

string line;while ((line = reader.ReadLine()) != null){

Console.WriteLine(line);}reader.Close();

Resource Management (suite)



Pour être sûr qu’une ressource est libérés

TextReader reader = new StreamReader(filename);try{

string line;while ((line = reader.ReadLine()) != null){

Console.WriteLine(line);}

}finally{

reader.Close();}

Encore mieux



using fournit un mécanisme propre pour contrôler le

temps de vie d’un objet. L’objet créé sera détruit à lafin du bloc d’instruction using.

L’objet doit implémenter l’interface IDisposable

using (TextReader reader = new

StreamReader(filename)){string line;while ((line = reader.ReadLine()) != null){

Console.WriteLine(line);}

}

Appeler la méthode Dispose à partir d’un destructeur

l E l IDi bl



class Example : IDisposable{

...~Example()

{ Dispose();}

public virtual void Dispose(){

if (!this.disposed){

try {// libérer les ressources précieuses

}finally {

this.disposed = true;GC.SuppressFinalize(this);}

}}

public void SomeBehavior() // méthode exemple{

checkIfDisposed();...

}...private void checkIfDisposed(){

if (this.disposed){

throw new ObjectDisposedException("Example");}

}

private Resource scarce;private bool disposed = false;

}



Part III :Créer des composants





Déclarer des propriétés



struct ScreenPosition{

public ScreenPosition(int X, int Y){this.x = rangeCheckedX(X);this.y = rangeCheckedY(Y);

}

public int X{

get { return this.x; }set { this.x = rangeCheckedX(value); }

}

public int Y{

get { return this.y; }

set { this.y = rangeCheckedY(value); }}

private static int rangeCheckedX(int x) { ... }private static int rangeCheckedY(int y) { ... }private int x, y;

}



Les propriétés Read-Only



struct ScreenPosition{...public int X{

get { return this.x; }}

}

origin.X = 140; // compile-time error

Les propriétés Write-Only



struct ScreenPosition{...public int X{

set { this.x = rangeCheckedX(value); }}

}Console.WriteLine(origin.X); // compile-time errororigin.X = 200; // okorigin.X += 10; // compile-time error



Les restrictions sur les propriétés

Il est interdit d’initialiser une propriété dans une struct



Il est interdit d initialiser une propriété dans une structou une classe en utilisant set (sans new)

Il est interdit d’utiliser une propriété comme unargument ref ou out argument.

Une propriété ne peut contenir qu’un set au plus et unget au plus.

get et set ne prennent pas d’arguments.

Il est interdit de déclarer une propriété const oureadonly.

ScreenPosition location;location.X = 40; //erreur

MyMethod(ref location.X); // erreur

const int X { get { ... } set { ... } } // erreur

Déclarer des propriétés dans des interfaces

interface IScreenPosition



{int X { get; set; }int Y { get; set; }

}

struct ScreenPosition : IScreenPosition{...public int X{

get { ... }

set { ... }}

public int Y{

get { ... }set { ... }

}

...}

class ScreenPosition:IScreenPosition{...public virtual int X

{ get { ... }set { ... }

}

public virtual int Y{

get { ... }set { ... }

}...

}

struct ScreenPosition: IScreenPosition

{ ...int IScreenPosition.X{

get { ... }set { ... }

}

int IScreenPosition.Y{get { ... }set { ... }

}...private int x, y;

}



Chapitre 15 :

Utiliser les Indexers

Que sont les indexers ?

Un indexer permet de voir un int comme un tableau de



Un indexer permet de voir un int comme un tableau debits et d’accéder aux bits de l’int

struct IntBits{

public IntBits(int initialBitValue){

bits = initialBitValue;}public bool this [ int index ]

{ get{

return (bits & (1 << index)) != 0;}

set

{ if (value) bits |= (1 << index);else

bits &= ~(1 << index);}

}private int bits;

}

Utiliser les indexers



Un indexer n’est pas une méthode.

Un indexer prend toujours un seul argument quispécifie quel élément est accédé.

Tous les indexers utilisent le mot clé this à la place du

nom de la méthode. Une classe ou une struct ne peutdéfinir qu’un seul indexer, il est toujours appelé this.

int adapted = 63;IntBits bits = new IntBits(adapted);

bool peek = bits[6];bits[0] = true; bits[31] = false;

Comparer les array et les indexers



Les indexers peuvcent utiliser des subscripts non-

numeric, alors que les arrays utilisent seulement dessubscripts entiers.

Les indexers peuvent être overloaded, alors que lesarrays ne le peuvent pas.

Les indexers ne peuvent être utilisés comme des

paramètres ref ou out, alors que les arrays le peuvent .

public int this [ string name ] { ... } // ok

public Name this [ PhoneNumber number ] { ... }public PhoneNumber this [ Name name ] { ... }

IntBits bits; // bits contient un indexerMethod(ref bits[1]);

Propriétés, Arrays, et Indexers



struct Wrapper

{ int[] data;...public int this [int i]{

get { return this.data[i]; }set { this.data[i] = value; }

}}

Wrapper wrap = new Wrapper();...int[] myData = new int[2];myData[0] = wrap[0];

myData[1] = wrap[1];myData[0]++;myData[1]++;

Déclarer des indexers dans des interfaces

interface IRawInt{



{bool this [ int index ] { get; set; }

}

struct RawInt : IRawInt{...public bool this [ int index ]{get { ... }

set { ... }}...

}

class RawInt : IRawInt{...public virtual bool this [ int index ]{get { ... }set { ... }

}

...}

struct RawInt : IRawInt{...

bool IRawInt.this [int index]{get { ... }set { ... }

}...

}



Chapitre 16 :

les Delegates et lesEvents

Créer un Delegate



Centre MédicalGérer les rendez-vous

AppelerProcessNextPatient

DelegateTypeRendez-vous

Gardien de Zoo 2

Soigne un antilopeCheckSabots

Gardien de Zoo 1

Soigne un lionCheckGriffes

AntilopeCheckSabots

LionCheckGriffes

Utiliser les delegateclass Controller{

d l t id t M hi D l t ()



delegate void stopMachineryDelegate();public stopMachineryDelegate StopMachinery{

get{return this.stopMachinery;

}

set{

this.stopMachinery = value;}

public void Add(stopMachineryDelegate stopMethod){

this.stopMachinery += stopMethod;}

public void Remove(stopMachineryDelegate stopMethod){

this.stopMachinery -= stopMethod;}

public void ShutDown(){

this.stopMachinery();}private stopMachineryDelegate stopMachinery;

}

Utiliser les delegates (suite)



Controller control = new Controller();FoldingMachine folder = new FoldingMachine();WeldingMachine welder = new WeldingMachine();PaintingMachine painter = new PaintingMachine();...control.Add(folder.StopFolding);

control.Add(welder.FinishWelding);control.Add(painter.PaintOff);...control.ShutDown();

Créer un adaptateur de méthodes (Method Adapter)



void StopFolding(int shutDownTime);

...void FinishFolding(){

folder.StopFolding(0);}...this.stopMachinery += FinishFolding;

delegate void stopMachineryDelegate();

...this.stopMachinery += folder.StopFolding;

Utiliser les méthodes anonymes comme adaptateurs



Une méthode anonyme est une méthode qui n’a pas de

nom

et

this.stopMachinery += delegate { folder.StopFolding(0); };

control.Add(delegate { folder.StopFolding(0); } );

Caractéristiques des méthodes anonymes



Les paramètres sont spécifiés entre parenthèses juste

après le mot clé delegate.

Une méthode Anonymous peut retourner des valeurs,mais le type de retour doit correspondre à celui dudelegate auquel elle est ajoutée.

Le code d’une méthode anonymous est du code C#

ordinaire. Il peut contenir des instructions, des appelsà des méthodes, des définitions de variables, …etc.

control.Add(delegate(int param1, string param2){ /* le code qui utilise param1 et param2 */ });



Déclarer un Event



class TemperatureMonitor

{

public delegate void StopMachineryDelegate();

public event StopMachineryDelegate MachineOverheating;

...

}

Souscrire à un Event

T t M it t M it T t M it ()



TemperatureMonitor tempMonitor = new TemperatureMonitor();

...tempMonitor.MachineOverheating += delegate {folder.StopFolding(0) };

tempMonitor.MachineOverheating += welder.FinishWelding;

tempMonitor.MachineOverheating += painter.PaintOff;

De même, pour supprimer une méthode d’unévénement, utiliser l’opérateur -=

Déclencher un Event





{

public delegate void StopMachinerDelegate;

public event StopMachineryDelegate MachineOverheating;

...

private void Notify()

{

if (this.MachineOverheating != null)

{

this.MachineOverheating();

}

}...

}

Ecrire un Event Handler

namespace System



p y{public delegate void EventHandler(object sender, EventArgs args) ;

public class EventArgs{

...}

}

namespace System.Windows.Forms{public class Control :{public event EventHandler Click;...}

public class Button : Control{

...}}

class Example : System.Windows.Forms.Form{private System.Windows.Forms.Buttonokay;

...

public Example()

{this.okay = new

System.Windows.Forms.Button();

this.okay.Click += newSystem.EventHandler(this.okay_Click);

...}

private void okay_Click(object sender,System.EventsArgs args){...

}}



Chapitre 17 :introduire les Generics

Le problème avec les objets

public void Enqueue( object item );



using System.Collections;...Queue myQueue = new Queue();Circle myCircle = new Circle();myQueue.Enqueue(myCircle);...

myCircle = (Circle)myQueue.Dequeue();

Queue myQueue = new Queue();Circle myCircle = new Circle();myQueue.Enqueue(myCircle);...Clock myClock = (Clock)myQueue.Dequeue();//erreur à l’exécution

Queue myQueue = new Queue();int myInt = 99;myQueue.Enqueue(myInt); // box de int à un object(+ d’espace mem) ...myInt = (int)myQueue.Dequeue(); // unbox de l’object à un int

public void Enqueue( object item );public object Dequeue();

Les generics : la solution



using System.Collections.Generic;...Queue<Circle> myQueue = new Queue<Circle>();Circle myCircle = new Circle();

myQueue.Enqueue(myCircle);...myCircle = myQueue.Dequeue();

public class Queue<T> : ...

... public void Enqueue( T item );public T Dequeue();

Donc

Utiliser les generics

struct Person



struct Person{

...}

...Dictionary<string, Person> directory =new Dictionary<string, Person>();

Person john = new Person();directory["John"] = john;...john = directory["John"];

{

...}...Queue<int> intQueue = new Queue<int>();Queue<Person> personQueue = new Queue<Person>();Queue<Queue<int>> queueQueue = new Queue<Queue<int>>();

Il est possible pour une classe generic d’avoir multiple types deparamètres

Les generics et les contraintes

Il est possible d’ajouter des contraintes sur les éléments pour une



public class PrintableCollection<T> where T : IPrintable

Il est possible d ajouter des contraintes sur les éléments pour uneclasse generic

Les contraintes



Contrainte Description where T: struct Le type argument doit être une value type.

where T : class Le type argument doit être un reference type : class,interface, delegate, ou array type.

where T : new() Le type argument doit avoir un constructeur public sansparamètres. Lorsque elle est utilisée en conjonction avec

d’autres contraintes, la contrainte new() doit êtrespécifiée en dernier. where T : <base class name> Le type argument doit être ou dériver de la classe de base

spécifiée. where T : <interface name> Le type argument doit être ou implémenter l’ interface

spécifiée.

Les interfaces System.IComparable etSystem.IComparable<T>class Circle : System.IComparable{



...public int CompareTo(object obj)

{ Circle circObj = (Circle)obj;if (this.Area() == circObj.Area())

return 0;

if (this.Area() > circObj.Area())return 1;

return -1;}}

class Circle : System.IComparable<Circle>{

...public int CompareTo(Circle other){

if (this.Area() == other.Area())return 0;

if (this.Area() > other.Area())return 1;

return -1;}

public bool Equals(Circle other){

return (this.CompareTo(other) == 0);}

}

Créer une classe generic

Algorithme de construction de l’arbre binaire



If the tree, T, is empty

ThenConstruct a new tree T with the new item I as the node, and emptyleft and right sub-trees

ElseExamine the value of the node, N, of the tree, TIf the value of N is greater than that of the new item, IThenIf the left sub-tree of T is emptyThenConstruct a new left sub-tree of T with the item I as the node,and empty left and right sub-trees

ElseInsert I into the left sub-tree of T

End IfElseIf the right sub-tree of T is emptyThen

Construct a new right sub-tree of T with the item I as the node,and empty left and right sub-trees

ElseInsert I into the right sub-tree of T

End IfEnd If

End If

Schéma de l’arbre binaire



Insérer des éléments dans l’arbre



Créer une classe generic

Algorithme d’impression du contenu de l’arbre binaire



If the left sub-tree is not emptyThenDisplay the contents of the left sub-tree

End IfDisplay the value of the nodeIf the right sub-tree is not empty

ThenDisplay the contents of the right sub-treeEnd If

g p

Imprimer les éléments de l’arbre







Chapitre 18 :

Enumérer lesCollections

Utiliser foreach pour les collections énumérables.

Enumérer des éléments dans une collection



Une collection enumerable est une collection quiimplémente l’interfaceSystem.Collections.IEnumerable.

La classe System.Array est une collection quiimplémente l’interface IEnumerable.

L’interface IEnumerable contient une seule méthode :

Un objet enumerator implémente l’interfaceSystem.Collections.IEnumerator.

IEnumerator<T> et IEnumerable<T>.

IEnumerator GetEnumerator();

object Current {get;}bool MoveNext();void Reset();

Implémenter un Enumerator en utilisant un Iterator

class BasicCollection<T> : IEnumerable<T>{

private List<T> data = new List<T>();



private List<T> data = new List<T>();

public void FillList(params T [] items){for (int i = 0; i < items.Length; i++)

data.Add(items[i]);}

IEnumerator<T> IEnumerable<T>.GetEnumerator(){

for (int i = 0; i < data.Count; i++)yield return data[i];}

IEnumerator IEnumerable.GetEnumerator(){

// ...}

}

BasicCollection<string> bc = new BasicCollection<string>();bc.FillList("Twas", "brillig", "and", "the", slithy", "toves");foreach (string word in bc)

Console.WriteLine(word);

Implémenter une interface en utilisant un Iterator



public IEnumerable<T> Reverse

{get{

for (int i = data.Count - 1; i >= 0; i--)yield return data[i];

}}

BasicCollection<string> bc = new BasicCollection<string>();bc.FillList("Twas", "brillig", "and", "the", slithy", "toves");...foreach (string word in bc.Reverse)

Console.WriteLine(word);



Chapitre 19 :

Surcharger desopérateurs

Les contraintes sur les opérateurs

Il n’est pas possible de changer la précédence ou



Il n’est pas possible de changer la précédence ou

l’associativité d’un opérateur. Il n’est pas possible de changer la multiplicité d’un

operateur (le nombre d’opérandes).

Il n’est pas possible d’inventer de nouveaux symbolesd’opérateurs.

Il n’est pas permis de changer la signification d’unopérateur.

Certains opérateurs ne peuvent être surchargés. Exemple: l’opérateur point (member access).

Surcharger un opérateur

struct Hour{



{public Hour(int initialValue)

{ this.value = initialValue;}

public static Hour operator+ (Hour lhs, Hour rhs){

return new Hour(lhs.value + rhs.value);

}...private int value;

}

Un opérateur doit être public.

Un opérateur doit être static. Un opérateur n’est jamaispolymorphique (pas de virtual, abstract, override, ou sealed).

Un opérateur binaire a deux arguments explicites. Un opérateur unaire a un argument explicite

Créer des opérateurs symétriques

struct Hour{



public Hour(int initialValue)

{ this.value = initialValue;}...public static Hour operator+ (Hour lhs, Hour rhs){

return new Hour(lhs.value + rhs.value);

}public static Hour operator+ (Hour lhs, int rhs){

return lhs + new Hour(rhs);}...private int value;

}

Hour a = ...;

int b = ...;Hour sum = a + b;Hour som = b + a; // erreur

Définir des opérateurs d’incrémentation

t t H



struct Hour

{ ...public static Hour operator++ (Hour arg){

arg.value++;return arg;

}...private int value;

}

Hour now = new Hour(9);Hour postfix = now++;

Hour now = new Hour(9);Hour prefix = ++now;

Définir un opérateur d’incrémentation pour une classe

l H



class Hour

{ public Hour(int initialValue){

this.value = initialValue;}...public static Hour operator++(Hour arg){

return new Hour(arg.value + 1);}...private int value;

}

Définir les opérateurs en paires

Les opérateurs qui vont en paire doivent tous les deuxêtre définis Exemple: (== et !=) (< et >) (<= et >=) etc



être définis. Exemple: (== et !=), (< et >), (<= et >=),… etc.

Si les opérateurs == et != sont surchargés, il estrecommandé de surcharger Equals et GetHashCodestruct Hour{

public Hour(int initialValue){

this.value = initialValue;}...public static bool operator==(Hour lhs, Hour rhs){

return lhs.value == rhs.value;}

public static bool operator!=(Hour lhs, Hour rhs){

return lhs.value != rhs.value;}...private int value;

}





Documents

Cours Visual C Sharp