Transcript Equipe RAINBOW Laboratoire I3S

C#
Michel RIVEILL
[email protected] - http://www.essi.fr/~riveill
Laboratoire I3S
Ecole d’Ingénieur en Sciences Informatiques (ESSI)
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes et Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
2
Hello World
using System;
class Hello {
static void Main( ) {
Console.WriteLine("Hello world");
Console.ReadLine(); // Hit enter to finish
}
}
csc HelloWorld.cs /reference:System.Windows.Forms.dll
16/07/2015
3
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes et Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
4
C#
Orienté composant
 C# est le premier langage orienté composant dans la famille C/C++
 Composant?





Un module indépendant, réutilisable
Plus gros grain que des objets (qui sont des constructions langages)
Incluent de multiple classes
Généralement indépendant d’un langage
Celui qui écrit un composant, ne connaît pas celui qui va l’utiliser
(entreprises différentes, langages de programmation différents)
 Les composants sont des objets de première classe



Propriétés, méthodes, évènements
Attributs au moment de la conception et à l’exécution
Génération de documentation au format XML
 Programmation en une étape


16/07/2015
Pas de fichiers d’entête (.h), de description IDL, etc.
Peut être embarqué dans des pages ASP
5
C#
Tout est object
 Vue traditionnelle
 C++, Java : types primitifs sont ‘magiques’ et ne
peuvent pas interopérer avec des objets
 Smalltalk, Lisp : types primitifs sont des objets mais
avec un important surcoût à l’exécution
 C# unifie les deux approches, avec de bonne
performance

Simplicité utilisée partout dans le framework
 Augmente l’extensibilité et la réutilisabilité
 Nouveaux types primitifs : Décimal, SQL…
 Collections, etc., fonctionnent pour tous les types
16/07/2015
6
C#
Logiciel robuste
 Ramassage des miettes (Garbage collection)
 Pas de perte de mémoire et de gestion de pointeur
 Exceptions
 Contrôle de type
 Pas de variables non initialisée
 Les ‘cast’ sont contrôlés
 Gestion de versions
 Prévient des erreurs usuelles
 i.e. if (x = y) ...
 Programmation en une étape
 Moins de ‘copier-coller’, source d’erreur
16/07/2015
7
C#
Préserver les acquis
 Hérite de C++
 Espace de nom (Namespaces), pointeurs (dans le
code ‘non-sûr’ - unsafe code), unsigned types, etc.
 Quelques changements, mais aucun pour le plaisir 
 Intéroperabilité
 C# parle avec XML, SOAP, COM, DLLs ainsi que tous
les langage du framework .NET
 Augmente la productivité
 Facile à apprendre
 Des millions de lignes de C# sont dans .NET
16/07/2015
8
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
9
Types
 Un programme C# est une collection de type

Classes, structures, énumérations, interfaces, delegates
 C# fournis un ensemble de types prédéfinis

i.e. int, byte, char, string, object, …
 Chaque programmeur peut créer ses propres types
 Chaque donnée et portion de code est défini par un type

Pas de variables globales, pas de fonctions globales
 Les types sont :



Des données membres : champs, constantes, tableaux, évènements
Des fonctions membres : Méthodes, opérateurs, constructeurs,
destructeurs, propriétés, indexeurs
D’autres types : classes, structures, énumérations, interfaces, delegates
 Les types peuvent être instancié…

…et après être utilisés : appel de méthode, get et set de propriétés, etc.
 Les types peuvent être convertis, implicitement ou explicitement
 Les types sont organisé en espace de noms, fichiers et assemblies

l’ensemble forme une hiérarchie
 Il y a 2 catégories de types : valeur et référence
16/07/2015
10
Types
Un seul système de type
 Type valeur
int i = 123;
Contient des données
string s = "Hello world";
 Ne peut être ‘null’
 Primitives
int i; float x;
 Enumératios
enum State { Off, On }
 Structures
struct Point {int x,y;}
 Type référence
i
123
 Contient des références
vers des objets
s
"Hello world"
 Peut être ‘null’
 Racine
object
 Chaîne
string
 Classes
class Foo: Bar, IFoo {...}
 Interfaces
interface IFoo: IBar {...}
 Tableau
string[] a = new string[10];
 Delegates
delegate void Empty();

16/07/2015
11
Types
Un seul système de type
Value (Struct)
Reference
(Class)
Actual value
Memory location
Stack, member
Heap
Always has value
May be null
Default value
0
null
Aliasing (in a
scope)
No
Yes
Copy data
Copy reference
Variable holds
Allocated on
Nullability
Assignment means
16/07/2015
12
Types
Un seul système de type
 Bénéfice des types valeurs




Pas d’allocation dans le tas, moins de travail
pour le GC
Meilleure utilisation de la mémoire
Moins de référence indirecte
Un seul système de type

16/07/2015
Pas de dichotomie type primitif/objet
13
Types
Conversions
 Conversion implicite
Fonctionne automatiquement et sans possibilité d’échec
 Pas de perte de précision/d’information
 Conversion explicite
 Nécessite un ‘cast’
 Peu être refusée
 De l’information/précision peut être perdue
 Conversion implicite et explicite sont précisées par le programmeur

int x = 123456;
long y = x;
short z = (short)x;
// implicit
// explicit
double d = 1.2345678901234;
float f = (float)d;
long l = (long)d;
// explicit
// explicit
16/07/2015
14
Types
Un système de type unifié
 Tout est objet


Tous les types héritent du type objet
Toute donnée peut être sauvegardée,
échangée et manipulée de la même manière
object
Stream
MemoryStream
16/07/2015
Hashtable
int
double
FileStream
15
Types
Un système de type unifié
 Polymorphisme
 Capacité d’effectuer une opération sur un objet sans
connaître le type précis de l’objet (et donc le code qui
sera réellement exécuter)
 S’appuie sur les interfaces de objets et sur les relations
de conformité entre les types
void Poly(object o) {
Console.WriteLine(o.ToString());
}
Poly(42);
Poly(“abcd”);
Poly(12.345678901234m);
Poly(new Point(23,45));
16/07/2015
16
Types
Un système de type unifié
 Question : Comment peut-on traiter les valeur et les références de la
même manière ?

Comment un int (type valeur) peut être converti en un objet (type
référence) ?
 Réponse : Boxing!


Seulement les types valeurs peuvent être ‘boxed’ (encapsulé)
Les types références n’ont pas à être ‘boxed’
 Boxing



Copie un type valeur dans un type référence (objet)
Chaque type valeur à une correspondance “cachée” dans un type
référence
Une copie d’un type référence est interprétée comme une copie du
type valeur


Un type valeur est converti de manière implicite dans un type référence
(objet)

16/07/2015
Les types valeurs n’ont jamais de synonyme (d’alias)
“up cast”
17
Types
Unified Type System
 Unboxing


Inverse operation of boxing
Copies the value out of the box


Requires an explicit conversion


16/07/2015
Copies from reference type to value type
May not succeed (like all explicit conversions)
Essentially a “down cast”
18
Types
Un système de type unifié
 Unboxing


Opération inverse du boxing
Extrait la valeur de la ‘boite’


Copies depuis une référence type to value type
Requiert une conversion explicite


Peut ne pas être acceptée (comme toute les autres
conversions explicites)
“down cast”
 Boxing et unboxing
int i = 123;
i
object o = i;
o
int j = (int)o;
16/07/2015
123
System.Int32
123
j
123
19
Types
Un système de type unifié
 Benefice du boxing
Permet le polymorphisme pour tous les types (y compris les types
valeurs)
 Les classes ‘collections’ fonctionnent avec tous les types
 Elimine la nécessité de construire manuellement des classes
d’encapsulation
 On trouve plein d’exemple d’utilisation dans le Framework .NET
 Désavantage du boxing
 Performance
 La nécessité du boxing est moindre quand le CLR supportera la
généricité (C++ templates)

Hashtable t = new Hashtable();
t.Add(0, "zero");
t.Add(1, "one");
string s = string.Format(
t.Add(2, "two");
"Your total was {0} on {1}",
total, date);
20
16/07/2015
Types prédéfinis
 Valeur





Type entier
Type réel
decimal
bool
char
 Référence
 object
 string
16/07/2015
Signed
sbyte, short,
int, long
Unsigned
byte, ushort,
uint, ulong
Character
char
Floating
point
float, double,
decimal
Logical
bool
21
Types prédéfinis
C# Type
System Type
Size (bytes)
Signed?
sbyte
System.Sbyte
1
Yes
short
System.Int16
2
Yes
int
System.Int32
4
Yes
long
System.Int64
8
Yes
byte
System.Byte
1
No
ushort
System.UInt16
2
No
uint
System.UInt32
4
No
ulong
System.UInt64
8
No
16/07/2015
22
Predefined Types
char
 Escape sequence characters (partial list)
Char
Meaning
Value
\’
Single quote
0x0027
\”
Double quote
0x0022
\\
Backslash
0x005C
\0
Null
0x0000
\n
New line
0x000A
\r
Carriage return
0x000D
\t
Tab
0x0009
16/07/2015
30
Predefined Types
Reference Types
Root type
object
Character string
string
16/07/2015
31
Predefined Types
object
 Root of object hierarchy
 Storage (book keeping) overhead


0 bytes for value types
8 bytes for reference types
 An actual reference (not the object)
uses 4 bytes
16/07/2015
C# Type
System Type
Size (bytes)
object
System.Object
0/8 overhead
32
Predefined Types
object Public Methods
 public bool Equals(object)
 protected void Finalize()
 public int GetHashCode()
 public System.Type GetType()
 protected object
MemberwiseClone()
 public void Object()
 public string ToString()
16/07/2015
33
Predefined Types
string
 An immutable sequence of Unicode
characters
 Reference type
 Special syntax for literals

string s = “I am a string”;
C# Type
System Type
Size (bytes)
String
System.String
20 minimum
16/07/2015
34
Predefined Types
string
 Normally have to use escape characters
string s1= “\\\\server\\fileshare\\filename.cs”;
 Verbatim string literals

Most escape sequences ignored

Except for “”
 Verbatim literals can be multi-line
string s2 = @“\\server\fileshare\filename.cs”;
16/07/2015
35
Types
 Types définis par l’utilisateur
Enumerations
Arrays
Interface
enum
int[], string[]
interface
Reference type
class
Value type
struct
Function pointer
16/07/2015
delegate
36
Types
Enums
 An enum defines a type name for a related group of symbolic




constants
Choices must be known at compile-time
Strongly typed
 No implicit conversions to/from int
 Can be explicitly converted
 Operators: +, -, ++, --, &, |, ^, ~, …
Can specify underlying type
 byte, sbyte, short, ushort, int, uint, long, ulong
All enums derive from System.Enum
 Provides methods to





16/07/2015
determine underlying type
test if a value is supported
initialize from string constant
retrieve all values in enum
…
37
Types
Enums
enum Color: byte {
Red
= 1,
Green = 2,
Blue = 4,
Black = 0,
White = Red | Green | Blue
}
Color c = Color.Black;
Console.WriteLine(c);
Console.WriteLine(c.Format());
16/07/2015
// 0
// Black
38
Types
Arrays
 Un tableau permet à un groupe d’éléments
d’un type particulier d’être stocker dans des
blocks contigus de mémoire
 Les tableaux sont de types références
 Dérivé de System.Array
 Premier élément du tableau ‘0’
 Les tableaux peuvent être multidimentionel

Chaque tableau connaît sa longueur et son
rang
 Les bornes sont vérifiées
16/07/2015
39
Types
Arrays
 Déclaration
int[] primes;
 Allocation
int[] primes = new int[9];
 Initialisation
int[] prime = new int[] {1,2,3,5,7,11,13,17,19};
int[] prime = {1,2,3,5,7,11,13,17,19};
 Accès
prime2[i] = prime[i];
 Enumération
foreach (int i in prime) Console.WriteLine(i);
16/07/2015
40
Types
Arrays
 Tableau multidimensional

Régulier



Irrégulier



16/07/2015
int[,] matR = new int[2,3];
Il peut être initialisé de manière déclarative
int[,] matR =
new int[2,3] { {1,2,3}, {4,5,6} };
Un tableau de tableaux
int[][] matJ = new int[2][];
Doit être initialisé par programme
41
Types
Interfaces
 Une interface définie un contrat
 Elle contient méthodes, propriétés, indexeurs,
évènements
 Chaque classe or structure implémentant une interface
doit supporter toute les parties du contrat
 Les interfaces permettent le polymorphisme
 Plusieurs classes et structures peuvent implémenter la
même interface
 Un interface ne contient pas d’implémentation
 Elle doit être implémenté par une classe ou une
structure
16/07/2015
42
Types
Classes
 Type référence défini par l’utilisateur
 Similaire aux classes C++ ou Java
 Héritage simple sur les classe
 Peuvent implémenter de multiples interfaces
 Membres
 Constantes, champ (fields), méthodes, opérateurs
(constructeurs et destructeurs)
 Propriétés, indexeurs, évènements
 Membres par classe (static) ou par instance
 Contrôle d’accès
 public, protected, private, internal,
protected internal
 Le mode par défaut est private
 Instantancié par l’opérateur new
16/07/2015
43
Types
Structs
 Similaire aux classes, mais
 Type valeur défini par l’utilisateur
 Hérite toujours d’objet
 Ideal pour des objets ‘légers’
 int, float, double, etc., sont des structures
 Permet la définition de type primitifs par l’utilisateur
Complex, point, rectangle, color, rational
Héritage multiple des interfaces
Même membres que les classes
Contrôle d’accès
 public, internal, private
Instancié par l’opérateur new





16/07/2015
44
Types
Classes and Structs
struct SPoint { int x, y; ... }
class CPoint { int x, y; ... }
SPoint sp = new SPoint(10, 20);
CPoint cp = new CPoint(10, 20);
sp
10
20
cp
CPoint
10
20
16/07/2015
45
Types
Delegates
 Un délégué (delegate) est un type référence
qui défini la signature d’une méthode
 Quand il est instancié, un délégué peut faire
référence à une ou plusieurs méthodes

De manière intuitive : un pointeur sur une
fonction dans le modèle objet
 Sert de base pour la gestion des évènements
16/07/2015
46
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
47
Structure d’un programme
Survol
 Organisation des types
 Espaces des noms
 Références
 Méthode principale (main)
 Syntaxe
16/07/2015
48
Structure d’un programme
Organisation des types
 Organisation physique

Les types sont définis dans
des fichiers




Les fichiers sont compilés en
modules



Un fichier peut contenir
plusieurs types
Un type est défini une seule
fois
Pas d’ordre dans les
déclarations
Assembly
Module
File
Type
Un module est un fichier DLL
ou EXE
Un module peut être le
résultat de la compilation de
plusieurs fichiers
Les modules sont regroupés
en assemblage
16/07/2015
49
Structure d’un programme
Espaces de noms
 Un nom de type doit être unique au sein d’un espace
de nom (Namespace)
 Permet l’organisation logique des types
 Il n’y a pas de relation entre les espaces de noms et
les fichiers (différence avec Java)


un assemblage peut définir plusieurs espaces de nom
Un espace de nom peut être commun à plusieurs
assemblages
 La désignation d’un type par son nom qualifié
implique l’inclusion de tout l’espace de nom dans
lequel il est défini
16/07/2015
50
Structure d’un programme
Espaces de noms
namespace N1 {
class C1 {
class C2 {
}
}
namespace N2 {
class C2 {
}
}
}
// N1
// N1.C1
// N1.C1.C2
// N1.N2
// N1.N2.C2
 Il est toujours possible d’utiliser le nom qualifié
 La directive using permet de s’en passer
using N1;
C1 a;
N1.C1 b;
// The N1. is implicit
// Fully qualified name
C2 c;
N1.N2.C2 d;
C1.C2 e;
// Error! C2 is undefined
// One of the C2 classes
// The other one
16/07/2015
51
Structure d’un programme
Espaces de noms
 La directive using permet aussi de créer des synonymes
using C1 = N1.N2.C1;
using N2 = N1.N2;
C1 a;
N2.C1 b;
// Refers to N1.N2.C1
// Refers to N1.N2.C1
 Quelques règles de bon usage :



16/07/2015
Mettre tous ses types dans un unique espace de noms
Avoir un espace de nom par projet
Regarder comment le framework .NET est organisé
52
Structure d’un programme
Références
 Chaque référence identifie un assemblage
 Utiliser les directives /r ou /reference
dans le compilateur C#
csc HelloWorld.cs /reference:System.WinForms.dll
 L’espace de nom défini les noms au niveau
langage

Permet de ne pas qualifier chaque type
 La référence précise quel assemblage utiliser
16/07/2015
53
Structure d’un programme
Méthode Main
 L’éxecution d’un programme démarre à la
méthode statique Main()
 Une seule méthode avec une de ces
signatures par assemblage




16/07/2015
static
static
static
static
void Main()
int Main()
void Main(string[] args)
int Main(string[] args)
54
Structure d’un programme
Syntaxe
 Identificateurs






Noms pour les types, les méthodes, les
champs, etc.
Un seul mot sans espace
Caractère Unicode
Le premier caractère est soit une lettre soit ‘_’
Sensible à la casse
Ne doit pas être un mot clé

16/07/2015
Sauf si préfixé par ‘@’
55
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
56
Instructions
Survol
 Fidèle à C++
 if, while, do
 nécessite une expression booléenne
 Goto
 ne peut sauter à travers les blocks
 switch
 Chaque entrée doit être terminée par un break ou
return ou goto
 Foreach, checked, unchecked
 Ça c’est nouveau
 Les expressions ne peuvent pas être utilisée à la
place des instructions
16/07/2015
void Foo() {
i == 1;
}
// error
57
Instructions
Survol





Expressions
 checked, unchecked
 lock
 using
Conditionnels
 if
 Switch
Boucles
 while
 do
 for
 foreach
Sauts
 break
 continue
 goto
 return
 throw
Exceptions
 try
 throw
16/07/2015
58
Instructions
syntaxe
 Instructions terminées
par ‘;’
 Bloc d’instruction
‘{‘ ... ‘}’ ne nécessite
pas de ‘;’
 Commentaires


16/07/2015
static void Main() {
F();
G();
{
// Start block
H();
;
// Empty statement
I();
}
// End block
}
// commentaire sur une seule ligne
/* Commentaire sur
plusieurs
lignes
*/
59
Intructions
Variables et constantes
static void Main() {
const float pi = 3.14f;
const int r = 123;
Console.WriteLine(pi * r * r);
int a;
int b = 2, c = 3;
a = 1;
Console.WriteLine(a + b + c);
}
 Règle de portée des déclarations usuelles
 Mais impossibilité de redéfinir une variable à l’intérieur d’un bloc
{
int x;
{
int x;
}
}
16/07/2015
// Error: can’t hide variable x
60
Instructions
Variables
 Une variable doit être initialisée avant d’être lue
 Explicitement ou automatiquement
 Un passage en paramètre est assimilé à une lecture
 L’initialisation automatique est possible pour des
champs statiques, des variables de classes ou des
éléments de tableaux
void Foo() {
string s;
Console.WriteLine(s);
}
16/07/2015
// Error
61
Instructions
goto
 goto permet de tranferer le contrôle à la fin
du bloc ou hors du bloc, jamais à un bloc
interne
static void Find(int value, int[,] values,
out int row, out int col) {
int i, j;
for (i = 0; i < values.GetLength(0); i++)
for (j = 0; j < values.GetLength(1); j++)
if (values[i, j] == value) goto found;
throw new InvalidOperationException(“Not found");
found:
row = i; col = j;
}16/07/2015
62
Instructions
Expression
 Affectation, appel de méthode, ++, --, new
static void Main() {
int a, b = 2, c = 3;
a = b + c;
a++;
MyClass.Foo(a,b,c);
Console.WriteLine(a + b + c);
a == 2;
// ERROR!
}
16/07/2015
63
instructions
if
 if (expression booléenne)
int Test(int a, int b) {
if (a > b)
return 1;
else if (a < b)
return -1;
else
return 0;
}
16/07/2015
64
Instructions
switch
int Test(string label) {
int result;
switch(label) {
case null:
goto case “runner-up”;
case “fastest”:
case “winner”:
result = 1; break;
case “runner-up”:
result = 2; break;
default:
result = 0;
}
return result;
}
16/07/2015
65
Instructions
while
 La aussi il faut une expression booléenne
int i = 0;
while (i < 5) {
...
i++;
int i = 0;
}
do {
...
i++;
}
while (i < 5);
16/07/2015
while (true) {
...
}
66
Instructions
for
for (int i=0; i < 5; i++) {
...
}
for (;;) {
...
}
16/07/2015
67
Instructions
foreach
 Permet de parcourir un tableau
public static void Main(string[] args) {
foreach (string s in args)
Console.WriteLine(s);
}
 Permet de parcourir une collection
 Implémenté par l’interface IEnumerable
foreach (Customer c in
customers.OrderBy("name")) {
if (c.Orders.Count != 0) {
...
}
}
16/07/2015
68
Instructions
Sauts
 break
 Termine la boucle
 continue
 Termine l’itération de la boucle en cours
 goto <label>
 Transfert l’exécution au label
 return [<expression>]
 Termine la méthode
 throw
 Lève une exception
16/07/2015
69
Instructions
Exception
 Une exception est une instance de la classe
System.Exception ou d’une classe dérivée
 Contient des informations à propos de l’exception
 Propriétés



Message
StackTrace
InnerException
 try...catch...finally
 try permet de lever une exception
 catch permet de traiter les exceptions
Il est possible d’avoir plusieurs bloc catch pour différentes
exceptions
 finally contient le code qui doit toujours être executé
 Il n’est pas possible de sortir d’un bloc finally par un saut (e.g.
goto)

16/07/2015
70
Instructions
Exception
 Il est possible de relever la même exception ou de la capturer
(bloc catch) pour en lever une autre
try {
Console.WriteLine("try");
throw new Exception(“message”);
}
catch (ArgumentNullException e) {
Console.WriteLine(“caught null argument");
}
catch {
Console.WriteLine("catch");
}
finally {
Console.WriteLine("finally");
}
16/07/2015
71
instructions
Synchronisation
 Lock


Mutuelle exclusion
Mis en oeuvre à l’aide de la classe
System.Threading.Monitor
public class CheckingAccount {
decimal balance;
public void Deposit(decimal amount) {
lock (this) {
balance += amount;
} }
public void Withdraw(decimal amount) {
lock (this) {
balance -= amount;
} } }
16/07/2015
72
Instuctions
using
 C# possède un ramassage des miettes (garbage collection)
Ce mécanisme ne permet pas de déterminer le moment
auquel la mémoire sera libérée
 Et donc de contrôler l’exécution des destructeurs
 Les objects qui nécessitent d’être nettoyer lors de leur
destruction doivent implémenter l’interface
System.IDisposable
 Méthode : Dispose()
 L’instruction using permet de créer une instance, de l’utiliser et
de la détruire en étant certain que la méthode Dispose soit
appelée à la fin de l’instruction.

16/07/2015
73
Statements
using Statement
public class MyResource : IDisposable {
public void MyResource() {
// Acquire valuble resource
}
public void Dispose() {
// Release valuble resource
}
public void DoSomething() {
...
}
using (MyResource r = new MyResource()) {
}
r.DoSomething();
}
// r.Dispose() is called
16/07/2015
74
Instructions
checked et unchecked
 Les instructions checked et unchecked permettent
de contrôler le débordement dans les expressions
arithmétique et les affectations


checked force le contrôle
unchecked supprime le contrôle
 Peut être utilisé pour une expression ou pour un bloc
d’instruction
 Le mode par défaut est unchecked
 L’utilisation de la directive /checked du compilateur
permet d’utiliser le mode checked par défaut
16/07/2015
75
Instructions
Entrée / sortie
 Entrée/sortie console
 System.Console.WriteLine();
 System.Console.ReadLine();
 Appel windows
 System.WinForms.MessageBox.Show();
string v1 = “some value”;
MyObject v2 = new MyObject();
Console.WriteLine(“First is {0}, second is {1}”,
v1, v2);
16/07/2015
76
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
77
Opérateurs
Survol
 C# défini un ensemble d’opérateurs aillant
une sémantique précise pour les types
prédéfinis
 Quelques opérateurs peuvent être
surchargés (e.g. +)
 Les tableaux suivants présentent les
opérateurs


16/07/2015
Par catégories triées par priorité
À l’intérieur d’une catégorie tous les
opérateurs ont la même priorité
78
Opérateurs
Précédence
Category
Primary
16/07/2015
Operators
Grouping: (x)
Member access: x.y
Method call: f(x)
Indexing: a[x]
Post-increment: x++
Post-decrement: x—
Constructor call: new
Type retrieval: typeof
Arithmetic check on: checked
Arithmetic check off: unchecked
79
Opérateurs
Précédence
Category
Operators
Unary
Positive value of: +
Negative value of: Not: !
Bitwise complement: ~
Pre-increment: ++x
Post-decrement: --x
Type cast: (T)x
Multiplicative
Multiply: *
Divide: /
Division remainder: %
16/07/2015
80
Opérateurs
Précédence
Category
Additive
Shift
Relational
16/07/2015
Operators
Add: +
Subtract: Shift bits left: <<
Shift bits right: >>
Less than: <
Greater than: >
Less than or equal to: <=
Greater than or equal to: >=
Type equality/compatibility: is
Type conversion: as
81
Opérateurs
Précédence
Category
Equality
Operators
Equals: ==
Not equals: !=
Bitwise AND
&
Bitwise XOR
^
Bitwise OR
|
Logical AND
&&
Logical OR
||
16/07/2015
82
Opérateurs
Précédence
Category
Ternary conditional
Assignment
16/07/2015
Operators
?:
=, *=, /=, %=, +=, -=, <<=, >>=,
&=, ^=, |=
83
Opérateurs
Associativité
 Affectation et affectation conditionelle sont
associatives à droite

x = y = z est évalué x = (y = z)
 Les autres opérateurs sont associatifs à
gauche

x + y + z est évalué (x + y) + z
 Si l’évaluation ne convient pas, il faut utiliser
les ‘(‘ …’)’
16/07/2015
84
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
85
Using Visual Studio.NET
 Types of projects







16/07/2015
Console Application
Windows Application
Web Application
Web Service
Windows Service
Class Library
...
86
Using Visual Studio.NET
 Windows








16/07/2015
Solution Explorer
Class View
Properties
Output
Task List
Object Browser
Server Explorer
Toolbox
87
Using Visual Studio.NET
 Building
 Debugging

Break points
 References
 Saving
16/07/2015
88
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
89
Using .NET Framework SDK
 Compiling from command line
csc /r:System.WinForms.dll class1.cs file1.cs
16/07/2015
90
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
91
Review
Key Object-Oriented Concepts
 Objects, instances and classes
 Identity

Every instance has a unique identity,
regardless of
its data
 Encapsulation



Data and function are packaged together
Information hiding
An object is an abstraction

16/07/2015
User should NOT know implementation details
92
Review
Key Object-Oriented Concepts
 Interfaces
 A well-defined contract
 A set of function members
 Types
 An object has a type, which specifies its
interfaces and their implementations
 A variable also can have a type
 Inheritance
 Types are arranged in a hierarchy


16/07/2015
Base/derived, superclass/subclass
Interface vs. implementation inheritance
93
Review
Key Object-Oriented Concepts
 Polymorphism
 The ability to use an object without knowing its
precise type
 Three main kinds of polymorphism



Inheritance
Interfaces
Late binding
 Dependencies
 For reuse and to facilitate development,
systems should be loosely coupled
 Dependencies should be minimized
16/07/2015
94
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
95
Interfaces
 An interface defines a contract
 An interface is a type
 Includes methods, properties, indexers, events
 Any class or struct implementing an interface
must support all parts of the contract
 Interfaces provide no implementation
 When a class or struct implements an
interface it must provide the implementation
 Interfaces provide polymorphism
 Many classes and structs may implement
a particular interface
16/07/2015
96
Interfaces
Example
public interface IDelete {
void Delete();
}
public class TextBox : IDelete {
public void Delete() { ... }
}
public class Car : IDelete {
public void Delete() { ... }
}
TextBox tb = new TextBox();
IDelete iDel = tb;
iDel.Delete();
Car c = new Car();
iDel = c;
iDel.Delete();
16/07/2015
97
Interfaces
Multiple Inheritance
 Classes and structs can inherit from
multiple interfaces
 Interfaces can inherit from multiple interfaces
interface IControl {
void Paint();
}
interface IListBox: IControl {
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {
}
16/07/2015
98
Interfaces
Explicit Interface Members
 If two interfaces have the same method
name, you can explicitly specify interface +
method name to disambiguate their
implementations
interface IControl {
void Delete();
}
interface IListBox: IControl {
void Delete();
}
interface IComboBox: ITextBox, IListBox {
void IControl.Delete();
void IListBox.Delete();
}
16/07/2015
99
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes et structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
100
Classes et Structures
Similarités
 Chacune
 Est un type défini par l’utilisateur
 Peut implémenter plusieurs interfaces
 Peut contenir

Données
 Champs, constantes, événements, tableaux

Fontions
 Méthodes, propriétés, indexeurs, opérateurs,
constructeurs

Définition de types
 Classes, structures, énumérations, interfaces,
delegates
16/07/2015
101
Classes et Structures
Différences
Class
Structure
Reference type
Value type
Can inherit from any
non-sealed reference type
No inheritance
(inherits only from
System.ValueType)
Can have a destructor
No destructor
Can have user-defined
parameterless constructor
No user-defined parameterless
constructor
16/07/2015
102
Classes et Structures
C# Structures vs. C++ Structures
 Différent des structures C++
C++ Struct
C# Struct
Same as C++ class, but all
members are public
User-defined value type
Can be allocated on the heap,
on the stack or as a member
(can be used as value or
reference)
Always allocated on the stack
or as a member
Members are always public
Members can be public,
internal or private
16/07/2015
103
Classes et Structures
Classes
public class Car : Vehicle {
public enum Make { GM, Honda, BMW }
Make make;
string vid;
Point location;
Car(Make m, string vid; Point loc) {
this.make = m;
this.vid = vid;
this.location = loc;
}
Car c =
new Car(Car.Make.BMW,
“JF3559QT98”,
new Point(3,7));
c.Drive();
public void Drive() {
Console.WriteLine(“vroom”); }
}
16/07/2015
104
Classes et Structures
Structures
public struct Point {
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int X { get { return x; }
set { x = value; } }
public int Y { get { return y; }
set { y = value; } }
}
Point p = new Point(2,5);
p.X += 100;
int px = p.X;
// px = 102
16/07/2015
105
Classes et Structures
Static vs. Instance
 Par défaut, les variables sont créées par instance
 Chaque instance a ses propres champs
 Les méthodes sont appliquées à une instance
 Les variables statiques sont associées à des types
 Les méthodes statique ne peuvent pas accéder aux
données de l’instance
 Pas de variable this dans les méthodes statiques
 Ne pas abuser des membres statiques
 Static est essentiellement utilisé pour des données
et des fonctions globales
16/07/2015
106
Classes and Structs
Directives d’accès
 Les directives d’accès permettent de spécifier qui peut utiliser un type ou un




membre
Les directives d’accès permettent de contrôler l’encapsulation
Les types au niveau haut (ceux associés à un namespace) peuvent être
public ou internal
Les membres des classes peuvent être public, private, protected,
internal ou protected internal
Les membres des structures peuvent public, private ou internal
If the access
modifier is
Then a member defined in type T and
assembly A is accessible
public
to everyone
private
within T only (the default)
protected
to T or types derived from T
internal
to types within A
protected internal
to T or types derived from T
or to types within A
16/07/2015
107
Classes et Structures
Classes abstraites et classes finales
 Une classe abstraite ne peut




pas être instantiée
Prévue pour être utilisée
comme une classe de base
Peuvent contenir des
fonctions membres
abstraites et non abstraites
Similaire à une interface
Ne peut être finale (‘sealed’)
 Une classe finale (sealed) ne
peut être utilisé comme une
classe de base
 Une classe finale ne peut être
abstraite
 Une structure est implicitement
finale
 Pourquoi des classes finales ?
 Pour empêcher une
dérivation non souhaitée
 Pour optimiser le code

16/07/2015
L’appel des fonctions
virtuellee peut être résolu
à la compilation
108
Classes et Structures
this
 Le mot clé this est une variable prédéfinie
accessible dans chaque fonction membre non
statique

Utilisé pour supprimer les ambiguïtés lors de l’accès
aux données ou aux fonctions membres
class Person {
string name;
public Person(string name) {
this.name = name;
}
public void Introduce(Person p) {
if (p != this)
Console.WriteLine(“Hi, I’m “ + name);
}
}
16/07/2015
109
Classes et Structures
base
 Le mot clé base est utilisé pour accéder aux
membres de classes masqués par un nom
similaire de la classe courante
class Shape {
int x, y;
public override string ToString() {
return "x=" + x + ",y=" + y;
}
}
class Circle : Shape {
int r;
public override string ToString() {
return base.ToString() + ",r=" + r;
}
}
16/07/2015
110
Classes et Structures
Constantes
 Une constante est une donnée membre qui
est évaluée à la compilation


Elle est implicitement statique
i.e. Math.PI
public class MyClass {
public const string version = “1.0.0”;
public const string s1 = “abc” + “def”;
public const int i3 = 1 + 2;
public const double PI_I3 = i3 * Math.PI;
//ERROR
public const double s = Math.Sin(Math.PI);
...
}
16/07/2015
111
Classes et Structures
Champs non modifiable (‘read-only’)
 Similaire à une constante, mais initialisé à l’exécution
Une fois initiatisé, il ne plus être modifié
 Différents à une constante
 Initialisé à l’exécution (vs. à la compilation)



Il n’est pas nécessaire de re-compiler les client de
la classe/struct qui le défini
Il peut être statique (et partagé par les différentes
instances) ou propre à chaque instance
public class MyClass {
public static readonly double d1 = Math.Sin(Math.PI);
public readonly string s1;
public MyClass(string s) { s1 = s; } }
16/07/2015
112
Classes et Structures
Propriétés
 Une propriété est un champ virtuel
 Ressemble à un champ, mais est implémenté
par du code
 Peut être read-only, write-only ou read/write
public class Button: Control {
private string caption;
public string Caption {
get { return caption; }
set { caption = value;
Repaint(); }
}
}
Button b = new Button();
b.Caption = "OK";
String s = b.Caption;
16/07/2015
113
Classes et Structures
Indexeurs
 Un indexeur permet à une instance d’être un
tableau virtuel
 Peut être surchargé (i.e. indexé par int et par string
 Peut être read-only, write-only ou read/write
public class ListBox: Control {
private string[] items;
public string this[int index] {
get { return items[index]; }
set { items[index] = value;
Repaint(); }
}
}
ListBox listBox = new ListBox();
listBox[0] = "hello";
Console.WriteLine(listBox[0]);114
16/07/2015
Classes et Structures
Méthodes
 Tout code est exécuté par une méthode
Constructeurs, destructeurs et operateurs sont des types
particuliers de méthodes
 Propriétés et indexeurs sont implémentés par des méthodes
get/set
 Une méthode peut recevoir des paramètres
 Passage par valeur
 Ou par référence : ref (dans la signature de la méthode et
dans l’appel)



Permet à une méthode de modifier la variable
La variable doit avoir une valeur avant l’appel
void RefFunction(ref int p) {
p++;
int x = 10;
}
RefFunction(ref x);
// x is now 11
16/07/2015
115
Classes et Structures
Méthodes
 Une méthode peut recevoir des paramètres (suite)


Et avoir des paramètres retours
 out (dans la signature de la méthode et dans l’appel)
 La méthode doit initialiser l’argument avant de terminer
Et des paramètres résultats
void OutFunction(out int p) {
p = 22;
int x;
}
OutFunction(out x);
// x is now 22
16/07/2015
116
Classes et Structures
Surcharge des méthodes
 Il est possible de surcharger le type d’une
méthode, i.e. avoir plusieurs méthodes avec
le même nom


void
void
void
void
Chacune doit avoir une signature unique
La signature est construite uniquement sur
les arguments (la valeur de retour est
ignorée)
Print(int i);
Print(string s);
Print(char c);
Print(float f);
// Error: duplicate signature
int Print(float f);
16/07/2015
117
Classes et Structures
Paramètres variables
 Une méthode peut avoir un nombre variable
de paramètres


Déclaré par le mots clé : params
Doit être le dernier argument
int Sum(params int[] intArr) {
int sum = 0;
foreach (int i in intArr)
sum += i;
return sum;
int sum = Sum(13,87,34);
}
16/07/2015
118
Classes et Structures
Méthodes non-virtuelles
 Méthodes non-virtuelles par défaut



Ne sont pas polymorphes
Elles ne peuvent pas être surchargées
Elles ne peuvent pas être abstraites
class Foo {
public void DoSomething(int i) {
...
}
}
Foo f = new Foo();
f.DoSomething();
16/07/2015
119
Classes et Structures
Méthodes virtuelles
 Définie dans une classe de base
 Peuvent être surchargées dans une classe
dérivée

Chaque classe fourni sa propre
implémentation de la méthode
 Peut contenir une implémentation par défaut
 Si l’on ne souhaite par de méthode par défaut,
utiliser une méthode abstraite
 Une forme de polymorphism
 Propriétés, indexeurs et évènements peut
aussi être virtuel
16/07/2015
120
Classes et Structures
Méthodes virtuelles
class Shape {
public virtual void Draw() { ... }
}
class Box : Shape {
public override void Draw() { ... }
}
class Sphere : Shape {
public override void Draw() { ... }
}
void HandleShape(Shape s) {
s.Draw();
...
}
HandleShape(new Box());
HandleShape(new Sphere());
HandleShape(new Shape());
16/07/2015
121
Classes et Structures
Méthodes abstraites
 une méthode abstraite est une méthode
virtuelle qui n’a pas d’implémentation
 Doit être dans une classe abstraite
 Doit être implémentée dans une classe
dérivée
16/07/2015
122
Classes et Structures
Méthodes abstraites
abstract class Shape {
public abstract void Draw();
}
class Box : Shape {
public override void Draw() { ... }
}
class Sphere : Shape {
public override void Draw() { ... }
}
void HandleShape(Shape s) {
s.Draw();
...
}
HandleShape(new Box());
HandleShape(new Sphere());
HandleShape(new Shape()); // Error!
16/07/2015
123
Classes et Structures
Surcharge de méthode
 La surcharge doit être explicite : override ou new
 Supprimer les surcharges accidentelle
 Les méthodes sont non virtuelles par défaut
class Base {
// //
version
version
1 2
} public virtual void Foo() {
Console.WriteLine("Base.Foo");
}
}
class Derived: Base {
// version
// version
1
2b
2a
new public
public
virtual
override
virtual
void
void
void
Foo()
Foo()
Foo()
{{ {
Console.WriteLine("Derived.Foo");
base.Foo();
} Console.WriteLine("Derived.Foo");
} }
}
16/07/2015
124
Classes et Structures
Constructeurs
 Un constructeur peut en appeler un autre
 this(...) dans la même classe
 base(...) pour la classe de base
 Le constructeur par défaut est base()
class B {
private int h;
public B() { }
public B(int h) { this.h = h; }
}
class D : B {
private int i;
public D() : this(24) { }
public D(int i) { this.i = i; }
public D(int h, int i) : base(h) { this.i = i; }
}
16/07/2015
125
Classes et Structures
Destructeurs
 Un destructeur est une méthode appelé par
lors de la destruction de l’objet (par GC)
 Permet d’éliminer les objets liés
 Les structures ne peuvent pas avoir de
destructeurs
class Foo {
~Foo() {
Console.WriteLine(“Destroyed {0}”, this);
}
}
16/07/2015
126
Classes et Structures
Surcharge d’opérateur
 Opérateur défini par les utilisateurs
 Toujours une méthode statique
class Car {
string vid;
public static bool operator ==(Car x, Car y) {
return x.vid == y.vid;
}
}
16/07/2015
127
Classes et Structures
Surcharge d’opérateur
 Opérateur unaire surchargeable
+
-
!
~
true
false
++
--
 Opérateur binaire surchargeable
+
-
*
/
!
~
%
&
|
^
==
!=
<<
>>
<
>
<=
>=
16/07/2015
128
Classes et Structures
Surcharge d’opérateur
 Tous les opérateurs ne sont pas
surchargeable


Accès aux membres, appel de méthodes,
affectation
sizeof, new, is, as, typeof, checked,
unchecked, &&, ||, and ?:
 La surcharge d’un opérateur binaire (e.g. *)
surcharge implicitement l’opérateur
d’affectation correspondant (e.g. *=)
16/07/2015
129
Classes et Structures
Surcharge d’opérateur
struct Vector {
int x, y;
public Vector(x, y)
{ this.x = x; this.y = y; }
public static Vector
operator +(Vector a, Vector b) {
return Vector(a.x + b.x, a.y + b.y);
}
...
}
16/07/2015
130
Classes et Structures
Opérateur de conversion
 Explicite et implicite conversion définies par
l’utilisateur
class Note {
int value;
// Convert to
public static
return ...;
}
// Convert to
public static
return ...;
}
}
16/07/2015
hertz – no loss of precision
implicit operator double(Note x) {
nearest note
explicit operator Note(double x) {
Note n = (Note)442.578;
double d = n;
131
Classes et Structures
Implementation des interfaces
 Peuvent implémenter plusieurs interfaces
 Doivent implémenter toutes les méthodes de l’interface héritée
public interface IDelete {
void Delete();
}
public class TextBox : IDelete {
public void Delete() { ... }
}
public class Car : IDelete {
public void Delete() { ... }
}
TextBox tb = new TextBox();
IDelete iDel = tb;
iDel.Delete();
16/07/2015
Car c = new Car();
iDel = c;
iDel.Delete();
132
Classes et Structures
Implementation des interfaces
 Implémentation explicite des interfaces en
cas de collision des noms
public interface IDelete {
void Delete();
}
public interface IFoo {
void Delete();
}
public class TextBox : IDelete, IFoo {
public void IDelete.Delete() { ... }
public void IFoo.Delete() { ... }
}
16/07/2015
133
Classes et Structures
Type interne
 Déclaré à l’interieur d’un autre type
 Bénéfice
 Un type interne peut accéder à tous les
membres du type qui le défini
 Un type interne est inconnu à l’extérieur du
type qui le défini
16/07/2015
134
Classes et Structures
is
 L’opérateur is permet de tester à l’exécution
le type d’un objet
static void DoSomething(object o) {
if (o is Car)
((Car)o).Drive();
}
 A utiliser avec modération

16/07/2015
Coûteux en temps…
135
Classes et Structures
as
 L’opérateur as converti une variable (si c’est
possible) dans le type demandé

Si ce n’est pas possible le résultat est null
static void DoSomething(object o) {
Car c = o as Car;
if (c != null) c.Drive();
}
 Test et conversion en une seule opération
 A utiliser avec modération
16/07/2015
136
Classes et Structures
typeof
 L’opérateur typeof retourne le type de
l’objet désigné (appel de System.Type)
 Utilise la réflexion pour obtenir
dynamiquement le type
Console.WriteLine(typeof(int).FullName);
Console.WriteLine(typeof(System.Int).Name);
Console.WriteLine(typeof(float).Module);
Console.WriteLine(typeof(double).IsPublic);
Console.WriteLine(typeof(Car).MemberType);
16/07/2015
137
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
138
Delegates
 Un ‘delegate’ est une référence sur une signature de méthode
 Une instance de ‘delegate’ instance défini une ou plusieurs
méthodes
 C’est un pointeur sur une fonction dans le monde objet
 Les méthodes peuvent être statique ou non
 Les méthodes peuvent retourner une valeur
 Permet le polymorphisme sur les fonctions/méthodes
 La base pour la programmation par évènement
delegate double Del(double x);
// Declare
static void DemoDelegates() {
Del delInst = new Del(Math.Sin);
double x = delInst(1.0);
}
16/07/2015
// Instantiate
// Invoke
139
Delegates multicast
 Un delegate peut appeler plusieurs méthodes

Les delegates multicast ne contiennent pas de fonction

le paramètre de retour est void
 Chaque delegate possède sa propre liste d’appel
Les méthodes sont appelées séquentiellement, dans leur
ordre d’ajout
 Opérateurs += et -=
 Utilisés pour insérer supprimer une méthode à la liste du
delegate
 Fonctionnent correctement avec les threads

16/07/2015
140
Delegates
Multicast Delegates
delegate void SomeEvent(int x, int y);
static void Foo1(int x, int y) {
Console.WriteLine("Foo1");
}
static void Foo2(int x, int y) {
Console.WriteLine("Foo2");
}
public static void Main() {
SomeEvent func = new SomeEvent(Foo1);
func += new SomeEvent(Foo2);
func(1,2);
// Foo1
// and Foo2 are called
func -= new SomeEvent(Foo1);
func(2,3);
// Only Foo2 is called
}
16/07/2015
141
Delegates
et interfaces
 Il est toujours possible d’utiliser des interfaces à
la place des delegates
 Interfaces sont plus puissantes
Appel à de multiples méthodes
 Mécanisme d’héritage

 Delegates sont plus élégant pour la gestion des
événements
Moins de code
 Implémentation facile de plusieurs traitants
d’événement dans une seule classe/structure

16/07/2015
142
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Evénements
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
143
Evènements

La programmation par évènement permet à un objet de prévenir un ensemble
d’objets en attente de la production d’un évènement





Modèle ‘publish-subscribe’
Basé sur un mécanisme de ‘call-back’
Le programmeur se concentre sur les réactions a exécuter et non pas sur le lien
évènement-réaction
Code plus lisible
Les évènement sont très utilisés lors de la construction d’IHM


L’utilisateur fait une action (click sur un bouton, déplace la souris, change une
valeur, etc.) et le programme réagit
Il existe de nombreuses autres utilisation, i.e.



Évènements temporels
Gestion des exécutions asynchrones (prévenir qu’un email est arrivé, qu’une
session Web a démarré)
C# supporte les évènements



Basé sur la notion de délégué
L’émetteur de l’événement, défini le délégué
Les clients de l’évènement enregistre le traitement à associer à l’évènement



16/07/2015
Appel de += et de -= sur les délégués
Il ne peuvent pas créer les évènements
Les délégués multicast permettent à plusieurs objets de s’enregistré pour le
même évènement
144
Evènements
Exemple coté composant (émetteur)
 Définir la signature de l’événement comme un
délégué
public delegate void EventHandler(object sender,
EventArgs e);
 Définir l’événement et sa logique d’emission
public class Button {
public event EventHandler Click;
protected void OnClick(EventArgs e) {
// This is called when button is clicked
if (Click != null) Click(this, e);
}
}
16/07/2015
145
Evènements
Exemple : coté utilisateur de l’évènement
 Définir le traitement à associer à l’évènement
et l’enregistrer
public class MyForm: Form {
Button okButton;
static void OkClicked(object sender,
EventArgs e) {
ShowMessage("You pressed the OK button");
}
public MyForm() {
okButton = new Button(...);
okButton.Caption = "OK";
okButton.Click +=
new EventHandler(OkClicked);
}
}
16/07/2015
146
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
147
Attributs

Les attributs permettent de décorer les différentes parties du code (assembly,
module, type, member, return value and parameter) avec des informations
additionnelles





L’URL contenant la documentation pour les classes
Le mode d’activation des transaction pour les méthodes
Le mapping XML pour la persistance
COM ProgID pour une class
Les attributs sont


Intégrés au code sans modification de la syntaxe d’origine
Extensibles




Sûr : le type des arguments est vérifié lors de la compilation
Pris en charge par le framework.NET Framework



Ils ne sont pas propre à un seul langage de programmation
Sauvegardé dans l’assembly metadata
Utilisés dans tous le framework .Net


Ils permettent d’ajouter des informations non supportées par C#
Pour en créer de nouveau, il suffit d’écrire une classe qui hérite de
System.Attribute
XML, services Web, sécurité, serialisation, modèle de composant, intéroperabilité
avec COM, configuration du code…
Les attributs peuvent être


16/07/2015
Associés aux types et aux fonctions membres
Examiné à l’exécution en utilisant la réflexion
148
Attributs
[HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)]
class SomeClass {
[Obsolete(“Use SomeNewMethod instead”)]
public void SomeOldMethod() {
...
}
public string Test([SomeAttr()] string param1) {
...
}
}
16/07/2015
149
Attributs
 Quelques uns des attributs prédéfinis du
framework .NET
Attribute Name
Description
Browsable
Should a property or event be
displayed in the property window
Serializable
Allows a class or struct to be serialized
Obsolete
Compiler will complain if target is used
ProgId
COM Prog ID
Transaction
Transactional characteristics of a class
16/07/2015
150
Attributs
[HelpUrl("http://SomeUrl/MyClass")]
class Class1 {}
[HelpUrl("http://SomeUrl/MyClass"),
HelpUrl("http://SomeUrl/MyClass”, Tag=“ctor”)]
class Class2 {}
Type type = typeof(MyClass);
foreach (object attr
in type.GetCustomAttributes() ) {
if ( attr is HelpUrlAttribute ) {
HelpUrlAttribute ha = (HelpUrlAttribute) attr;
myBrowser.Navigate( ha.Url );
}
}
16/07/2015
151
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
152
Directives pour le préprocesseur
 C# permet de préciser des directives au préprocesseur
 A la différence de C/C++, le préprocesseur est intégré au processeur
 Le préprocesseur de C++ supprime les include :

#include


Pas vraiment utile de les supprimer lors des compilations en une
seule étape ; par contre, compilation plus rapide
#define

Supprimé pour rendre le résultat plus lisible
 Assertions permettent de rendre le code plus lisible
 Une assertion est essentiellement une unité de test


Assertions peuvent tester des préconditions, postconditions et
invériants
Assertions sont activées uniquement en mode de mise au point
 Pour plus d’information :

16/07/2015
“Writing Solid Code”, by Steve Maguire, Microsoft Press, ISBN 155615-551-4
153
Directives pour le pré processeur
Directive
Description
#define, #undef
Define and undefine conditional
symbols
#if, #elif, #else,
#endif
Conditionally skip sections of code
#error, #warning
Issue errors and warnings
#region, #end
Delimit outline regions
#line
Specify line number
16/07/2015
154
Directives pour le pré processeur
Compilation conditionnelle
#define Debug
public class Debug {
[Conditional("Debug")]
public static void Assert(bool cond, String s) {
if (!cond) {
throw new AssertionException(s);
}
}
void DoSomething() {
...
// If Debug is not defined, the next line is
// not even called
Assert((x == y), “X should equal Y”);
...
}
}
16/07/2015
155
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
156
Commentaires en XML
 Les programmeurs n’aiment pas documenter le code,
 C# donne la possibilité de produire de la
documentation en lien avec le code compilé
 La javadoc de C#
 C# permet d’écrire ces commentaires en XML
 Début du commentaire : ///
 Fin du commentaire : fin de ligne
 Un document XML est généré lors de la compilation
du code avec l’argument /doc



16/07/2015
S’appuie sur un schéma XML prédéfini
Il est aussi possible d’ajouter ses propres balises
Certains commentaires sont ‘vérifiés’ : paramètres,
exceptions, types
157
Commentaires en XML
XML Tag
Description
<summary>, <remarks>
Type or member
<param>
Method parameter
<returns>
Method return value
<exception>
Exceptions thrown from method
<example>, <c>, <code>
Sample code
<see>, <seealso>
Cross references
<value>
Property
<paramref>
Use of a parameter
<list>, <item>, ...
Formatting hints
<permission>
Permission requirements
16/07/2015
158
Commentaires en XML
class XmlElement {
/// <summary>
///
Returns the attribute with the given name and
///
namespace</summary>
/// <param name="name">
///
The name of the attribute</param>
/// <param name="ns">
///
The namespace of the attribute, or null if
///
the attribute has no namespace</param>
/// <return>
///
The attribute value, or null if the attribute
///
does not exist</return>
/// <seealso cref="GetAttr(string)"/>
///
public string GetAttr(string name, string ns) {
;
}
}
Csc XmlElement.cs /doc
16/07/2015
159
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
160
Code ‘unsafe’
 Parfois, le contrôle de la mémoire est nécessaire
Gain en performance
 Accès à des structures binaires définies de manière externe
 Accès à du code existant
 Accès à des composants COM, importation de DLL
 C# permet d’indiquer les portions ou le programmeur souhaite
contrôler la gestion mémoire. Il peut alors utiliser :
 Le type pointer et l’arithmétidque sur les pointers
 Les opérateurs ->, *
 Les cast entre données
 Pas de ramassage de miettes (GC)
 À utiliser chaque fois qu’un programme inclue du code C/C++
 Mode opératoire
 Utiliser l’instruction fixed pour indiquer les données qui ne
doivent pas être affectée par le GC
 Utiliser l’opérateur stackalloc pour allouer la mémoire dans
le tas
161
16/07/2015

Code ‘unsafe’
unsafe void Foo() {
char* buf = stackalloc char[256];
for (char* p = buf; p < buf + 256; p++) *p = 0;
...
}
class FileStream: Stream {
int handle;
public unsafe int Read(byte[] buffer, int index,
int count) {
int n = 0;
fixed (byte* p = buffer) {
ReadFile(handle, p + index, count, &n, null);
}
return n;
}
[dllimport("kernel32", SetLastError=true)]
static extern unsafe bool ReadFile(int hFile,
void* lpBuffer, int nBytesToRead,
int* nBytesRead, Overlapped* lpOverlapped);
}
16/07/2015
162
Code ‘Unsafe’
C# et les pointers
 Le pouvoir a un prix


‘Unsafe’ veut dire non vérifiable
Code exécuté avec plus de précaution


16/07/2015
Avant d’exécuter le code
Lors du chargement
163
Plan

Introduction









Notions complémentaires










Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Quelques rappels sur les objets
Interfaces
Classes and Structures
Delegates
Events
Attributs
Directives pour le préprocesseur
Commentaires en XML
Code Unsafe
Pour aller plus loin
16/07/2015
164
Quelques ressources






http://msdn.microsoft.com
http://windows.oreilly.com/news/hejlsberg_0800.html
http://www.csharphelp.com/
http://www.csharp-station.com/
http://www.csharpindex.com/
http://msdn.microsoft.com/msdnmag/
issues/0900/csharp/csharp.asp
 http://www.hitmill.com/programming/dotNET/csharp.html
 http://www.c-sharpcorner.com/
 http://msdn.microsoft.com/library/
default.asp?URL=/library/dotnet/
csspec/vclrfcsharpspec_Start.htm
 Le site d’un étudiant de l’ESSI (merci Alain)

http://www.essisharp.ht.st/
16/07/2015
165