Post on 24-May-2015
C#
Michel RIVEILL
riveill@unice.fr - http://www.essi.fr/~riveill
Laboratoire I3S
Ecole d’Ingénieur en Sciences Informatiques (ESSI)
12/03/2014 2
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 3
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
12/03/2014 4
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 5
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 Pas de fichiers d’entête (.h), de description IDL, etc.
Peut être embarqué dans des pages ASP
12/03/2014 6
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
12/03/2014 7
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
12/03/2014 8
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
12/03/2014 9
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 10
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
12/03/2014 11
Types Un seul système de type
Type valeur
Contient des données
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
Contient des référencesvers des objets
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();
int i = 123;string s = "Hello world";
123i
s "Hello world"
12/03/2014 12
Types Un seul système de type
Value (Struct)Reference
(Class)
Variable holds Actual value Memory location
Allocated on Stack, member Heap
Nullability Always has value May be null
Default value 0 null
Aliasing (in a
scope)No Yes
Assignment means Copy data Copy reference
12/03/2014 13
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
Pas de dichotomie type primitif/objet
12/03/2014 14
TypesConversions
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; // implicitshort z = (short)x; // explicit
double d = 1.2345678901234;float f = (float)d; // explicitlong l = (long)d; // explicit
12/03/2014 15
TypesUn 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
MemoryStream FileStream
Stream Hashtable int double
object
12/03/2014 16
TypesUn 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));
12/03/2014 17
TypesUn 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 Les types valeurs n’ont jamais de synonyme (d’alias)
Un type valeur est converti de manière implicite dans un type référence (objet) “up cast”
12/03/2014 18
TypesUnified Type System
Unboxing
Inverse operation of boxing
Copies the value out of the box
Copies from reference type to value type
Requires an explicit conversion
May not succeed (like all explicit conversions)
Essentially a “down cast”
12/03/2014 19
TypesUn 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;
object o = i;
int j = (int)o;
123i
o
123j123
System.Int32
12/03/2014 20
TypesUn 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");t.Add(2, "two");
string s = string.Format("Your total was {0} on {1}", total, date);
12/03/2014 21
Types prédéfinis
Valeur
Type entier
Type réel
decimal
bool
char
Référence
object
string
Signedsbyte, short, int, long
Unsignedbyte, ushort, uint, ulong
Character char
Floating
point
float, double, decimal
Logical bool
12/03/2014 22
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
12/03/2014 30
Predefined Typeschar
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
12/03/2014 31
Predefined TypesReference Types
Root type object
Character string string
12/03/2014 32
Predefined Typesobject
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
C# Type System Type Size (bytes)
object System.Object 0/8 overhead
12/03/2014 33
Predefined Typesobject 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()
12/03/2014 34
Predefined Typesstring
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
12/03/2014 35
Predefined Typesstring
Normally have to use escape characters
Verbatim string literals
Most escape sequences ignored
Except for “”
Verbatim literals can be multi-line
string s1= “\\\\server\\fileshare\\filename.cs”;
string s2 = @“\\server\fileshare\filename.cs”;
12/03/2014 36
Types
Types définis par l’utilisateur
Enumerations enum
Arrays int[], string[]
Interface interface
Reference type class
Value type struct
Function pointer delegate
12/03/2014 37
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
determine underlying type
test if a value is supported
initialize from string constant
retrieve all values in enum
…
12/03/2014 38
Types Enums
enum Color: byte {Red = 1,Green = 2,Blue = 4,Black = 0,White = Red | Green | Blue
}
Color c = Color.Black;Console.WriteLine(c); // 0Console.WriteLine(c.Format()); // Black
12/03/2014 39
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
12/03/2014 40
Types Arrays
Déclaration
Allocation
Initialisation
Accès
Enumération
int[] primes;
int[] primes = new int[9];
int[] prime = new int[] {1,2,3,5,7,11,13,17,19}; int[] prime = {1,2,3,5,7,11,13,17,19};
prime2[i] = prime[i];
foreach (int i in prime) Console.WriteLine(i);
12/03/2014 41
Types Arrays
Tableau multidimensional
Régulier
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} };
Irrégulier
Un tableau de tableaux
int[][] matJ = new int[2][];
Doit être initialisé par programme
12/03/2014 42
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
12/03/2014 43
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
12/03/2014 44
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
12/03/2014 45
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);
10
20sp
cp
10
20
CPoint
12/03/2014 46
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
12/03/2014 47
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 48
Structure d’un programmeSurvol
Organisation des types
Espaces des noms
Références
Méthode principale (main)
Syntaxe
12/03/2014 49
Structure d’un programme Organisation des types
Organisation physique
Les types sont définis dans des fichiers Un fichier peut contenir
plusieurs types
Un type est défini une seule fois
Pas d’ordre dans les déclarations
Les fichiers sont compilés en modules 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
Assembly
Module
File
Type
12/03/2014 50
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
12/03/2014 51
Structure d’un programme Espaces de noms
Il est toujours possible d’utiliser le nom qualifié
La directive using permet de s’en passer
using N1;
C1 a; // The N1. is implicitN1.C1 b; // Fully qualified name
C2 c; // Error! C2 is undefinedN1.N2.C2 d; // One of the C2 classesC1.C2 e; // The other one
namespace N1 { // N1class C1 { // N1.C1class C2 { // N1.C1.C2}
} namespace N2 { // N1.N2class C2 { // N1.N2.C2}
} }
12/03/2014 52
Structure d’un programme Espaces de noms
La directive using permet aussi de créer des synonymes
Quelques règles de bon usage :
Mettre tous ses types dans un unique espace de noms
Avoir un espace de nom par projet
Regarder comment le framework .NET est organisé
using C1 = N1.N2.C1;using N2 = N1.N2;
C1 a; // Refers to N1.N2.C1N2.C1 b; // Refers to N1.N2.C1
12/03/2014 53
Structure d’un programmeRéférences
Chaque référence identifie un assemblage
Utiliser les directives /r ou /referencedans le compilateur C#
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
csc HelloWorld.cs /reference:System.WinForms.dll
12/03/2014 54
Structure d’un programmeMé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
static void Main()
static int Main()
static void Main(string[] args)
static int Main(string[] args)
12/03/2014 55
Structure d’un programmeSyntaxe
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é
Sauf si préfixé par ‘@’
12/03/2014 56
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 57
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 void Foo() {
i == 1; // error
}
12/03/2014 58
Instructions Survol
Expressions
checked, unchecked lock using
Conditionnels
if Switch
Boucles
while
do
for
foreach
Sauts
break
continue
goto
return
throw
Exceptions
try
throw
12/03/2014 59
Instructions syntaxe
Instructions terminées
par ‘;’
Bloc d’instruction
‘{‘ ... ‘}’ ne nécessite
pas de ‘;’
Commentaires
// commentaire sur une seule ligne
/* Commentaire sur plusieurs
lignes*/
static void Main() { F();G();{ // Start blockH();; // Empty statementI();
} // End block}
12/03/2014 60
IntructionsVariables 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; // Error: can’t hide variable x
}}
12/03/2014 61
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); // Error
}
12/03/2014 62
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;
}
12/03/2014 63
InstructionsExpression
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!
}
12/03/2014 64
instructionsif
if (expression booléenne)
int Test(int a, int b) {if (a > b)return 1;
else if (a < b)return -1;
elsereturn 0;
}
12/03/2014 65
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;
}
12/03/2014 66
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); while (true) {
...}
12/03/2014 67
Instructions for
for (int i=0; i < 5; i++) {...
}
for (;;) {...
}
12/03/2014 68
Instructions foreach
Permet de parcourir un tableau
Permet de parcourir une collection
Implémenté par l’interface IEnumerable
public static void Main(string[] args) {foreach (string s in args)
Console.WriteLine(s);}
foreach (Customer c incustomers.OrderBy("name")) {
if (c.Orders.Count != 0) {...
}}
12/03/2014 69
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
12/03/2014 70
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)
12/03/2014 71
InstructionsException
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");}
12/03/2014 72
instructionsSynchronisation
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;
} } }
12/03/2014 73
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.
12/03/2014 74
Statementsusing 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
12/03/2014 75
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
12/03/2014 76
InstructionsEntré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);
12/03/2014 77
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 78
OpérateursSurvol
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
Par catégories triées par priorité
À l’intérieur d’une catégorie tous les
opérateurs ont la même priorité
12/03/2014 79
OpérateursPrécédence
Category Operators
Primary
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
12/03/2014 80
OpérateursPré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: %
12/03/2014 81
OpérateursPrécédence
Category Operators
AdditiveAdd: +
Subtract: -
ShiftShift bits left: <<
Shift bits right: >>
Relational
Less than: <
Greater than: >
Less than or equal to: <=
Greater than or equal to: >=
Type equality/compatibility: is
Type conversion: as
12/03/2014 82
OpérateursPrécédence
Category Operators
EqualityEquals: ==
Not equals: !=
Bitwise AND &
Bitwise XOR ^
Bitwise OR |
Logical AND &&
Logical OR ||
12/03/2014 83
OpérateursPrécédence
Category Operators
Ternary conditional ?:
Assignment=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
12/03/2014 84
OpérateursAssociativité
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 ‘(‘ …’)’
12/03/2014 85
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 86
Using Visual Studio.NET
Types of projects
Console Application
Windows Application
Web Application
Web Service
Windows Service
Class Library
...
12/03/2014 87
Using Visual Studio.NET
Windows
Solution Explorer
Class View
Properties
Output
Task List
Object Browser
Server Explorer
Toolbox
12/03/2014 88
Using Visual Studio.NET
Building
Debugging
Break points
References
Saving
12/03/2014 89
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 90
Using .NET Framework SDK
Compiling from command line
csc /r:System.WinForms.dll class1.cs file1.cs
12/03/2014 91
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 92
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
User should NOT know implementation details
Review Key Object-Oriented Concepts
12/03/2014 93
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
Base/derived, superclass/subclass
Interface vs. implementation inheritance
12/03/2014 94
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
12/03/2014 95
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 96
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
12/03/2014 97
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();
InterfacesExample
12/03/2014 98
interface IControl {void Paint();
}
interface IListBox: IControl {void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {
}
InterfacesMultiple Inheritance
Classes and structs can inherit from
multiple interfaces
Interfaces can inherit from multiple interfaces
12/03/2014 99
interface IControl {void Delete();
}
interface IListBox: IControl {void Delete();
}
interface IComboBox: ITextBox, IListBox {
void IControl.Delete();
void IListBox.Delete();
}
InterfacesExplicit Interface Members
If two interfaces have the same method
name, you can explicitly specify interface +
method name to disambiguate their
implementations
12/03/2014 100
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 101
Classes et StructuresSimilarité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
12/03/2014 102
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
Classes et StructuresDifférences
12/03/2014 103
C++ Struct C# Struct
Same as C++ class, but all
members are publicUser-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 publicMembers can be public,
internal or private
Classes et StructuresC# Structures vs. C++ Structures
Différent des structures C++
12/03/2014 104
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;
}
public void Drive() { Console.WriteLine(“vroom”); }
}
Car c =new Car(Car.Make.BMW,
“JF3559QT98”, new Point(3,7));
c.Drive();
Classes et StructuresClasses
12/03/2014 105
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
Classes et StructuresStructures
12/03/2014 106
Classes et StructuresStatic 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
12/03/2014 107
Classes and StructsDirectives 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 internalto T or types derived from T
or to types within A
12/03/2014 108
Classes et StructuresClasses 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
L’appel des fonctions
virtuellee peut être résolu
à la compilation
12/03/2014 109
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);
}}
Classes et Structuresthis
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
12/03/2014 110
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;}
}
Classes et Structuresbase
Le mot clé base est utilisé pour accéder aux
membres de classes masqués par un nom
similaire de la classe courante
12/03/2014 111
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;//ERRORpublic const double s = Math.Sin(Math.PI);...
}
Classes et StructuresConstantes
Une constante est une donnée membre qui
est évaluée à la compilation
Elle est implicitement statique
i.e. Math.PI
12/03/2014 112
Classes et StructuresChamps 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; } }
12/03/2014 113
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;
Classes et StructuresProprié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
12/03/2014 114
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]);
Classes et StructuresIndexeurs
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
12/03/2014 115
Classes et StructuresMé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
12/03/2014 116
void OutFunction(out int p) {p = 22;
} int x;OutFunction(out x);// x is now 22
Classes et StructuresMé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
12/03/2014 117
void Print(int i);void Print(string s);void Print(char c);void Print(float f);// Error: duplicate signature
int Print(float f);
Classes et StructuresSurcharge 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
Chacune doit avoir une signature unique
La signature est construite uniquement sur
les arguments (la valeur de retour est
ignorée)
12/03/2014 118
int Sum(params int[] intArr) {int sum = 0;foreach (int i in intArr)sum += i;
return sum;}
int sum = Sum(13,87,34);
Classes et StructuresParamè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
12/03/2014 119
class Foo {public void DoSomething(int i) {...
}} Foo f = new Foo();
f.DoSomething();
Classes et StructuresMé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
12/03/2014 120
Classes et StructuresMé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
12/03/2014 121
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());
Classes et StructuresMéthodes virtuelles
12/03/2014 122
Classes et StructuresMé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
12/03/2014 123
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!
Classes et StructuresMéthodes abstraites
12/03/2014 124
Classes et StructuresSurcharge 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 Derived: Base { // version 1public virtual void Foo() {
Console.WriteLine("Derived.Foo"); }
}
class Base { // version 1}class Base { // version 2
public virtual void Foo() {Console.WriteLine("Base.Foo");
}}
class Derived: Base { // version 2anew public virtual void Foo() {
Console.WriteLine("Derived.Foo"); }
}
class Derived: Base { // version 2bpublic override void Foo() {
base.Foo();Console.WriteLine("Derived.Foo");
}}
12/03/2014 125
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; }
}
Classes et StructuresConstructeurs
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()
12/03/2014 126
class Foo {~Foo() {
Console.WriteLine(“Destroyed {0}”, this); }
}
Classes et StructuresDestructeurs
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
12/03/2014 127
class Car {string vid;public static bool operator ==(Car x, Car y) {return x.vid == y.vid;
}}
Classes et StructuresSurcharge d’opérateur
Opérateur défini par les utilisateurs
Toujours une méthode statique
12/03/2014 128
Classes et StructuresSurcharge d’opérateur
+ - ! ~
true false ++ --
Opérateur unaire surchargeable
Opérateur binaire surchargeable
+ - * / ! ~
% & | ^ == !=
<< >> < > <= >=
12/03/2014 129
Classes et StructuresSurcharge 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. *=)
12/03/2014 130
Classes et StructuresSurcharge 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);
}...
}
12/03/2014 131
class Note {int value;// Convert to hertz – no loss of precisionpublic static implicit operator double(Note x) {return ...;
}// Convert to nearest notepublic static explicit operator Note(double x) {return ...;
}}
Note n = (Note)442.578;double d = n;
Classes et StructuresOpérateur de conversion
Explicite et implicite conversion définies par
l’utilisateur
12/03/2014 132
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();
Classes et StructuresImplementation des interfaces
Peuvent implémenter plusieurs interfaces
Doivent implémenter toutes les méthodes de l’interface héritée
12/03/2014 133
public interface IDelete {void Delete();
}public interface IFoo {void Delete();
}public class TextBox : IDelete, IFoo {public void IDelete.Delete() { ... }public void IFoo.Delete() { ... }
}
Classes et StructuresImplementation des interfaces
Implémentation explicite des interfaces en
cas de collision des noms
12/03/2014 134
Classes et StructuresType 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
12/03/2014 135
Classes et Structuresis
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
Coûteux en temps…
12/03/2014 136
Classes et Structuresas
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
12/03/2014 137
Classes et Structurestypeof
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);
12/03/2014 138
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 139
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); // Instantiatedouble x = delInst(1.0); // Invoke
}
12/03/2014 140
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
12/03/2014 141
DelegatesMulticast 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 calledfunc -= new SomeEvent(Foo1);func(2,3); // Only Foo2 is called
}
12/03/2014 142
Delegateset 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
12/03/2014 143
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 144
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 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
12/03/2014 145
EvènementsExemple coté composant (émetteur)
Définir la signature de l’événement comme un
délégué
Définir l’événement et sa logique d’emission
public delegate void EventHandler(object sender, EventArgs e);
public class Button {public event EventHandler Click;
protected void OnClick(EventArgs e) {// This is called when button is clickedif (Click != null) Click(this, e);
}}
12/03/2014 146
EvènementsExemple : 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);}
}
12/03/2014 147
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 148
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 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
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
XML, services Web, sécurité, serialisation, modèle de composant, intéroperabilité avec COM, configuration du code…
Les attributs peuvent être
Associés aux types et aux fonctions membres
Examiné à l’exécution en utilisant la réflexion
12/03/2014 149
Attributs
[HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)]class SomeClass {[Obsolete(“Use SomeNewMethod instead”)]public void SomeOldMethod() { ...
}
public string Test([SomeAttr()] string param1) {...
}}
12/03/2014 150
Attributs
Attribute Name Description
BrowsableShould 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
Quelques uns des attributs prédéfinis du framework .NET
12/03/2014 151
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 );
}}
12/03/2014 152
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 153
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 :
“Writing Solid Code”, by Steve Maguire, Microsoft Press, ISBN 1-
55615-551-4
Directives pour le préprocesseur
12/03/2014 154
Directives pour le pré processeur
Directive Description
#define, #undefDefine and undefine conditional
symbols
#if, #elif, #else,
#endifConditionally skip sections of code
#error, #warning Issue errors and warnings
#region, #end Delimit outline regions
#line Specify line number
12/03/2014 155
#define Debugpublic 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 calledAssert((x == y), “X should equal Y”);...
}}
Directives pour le pré processeurCompilation conditionnelle
12/03/2014 156
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 157
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
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
12/03/2014 158
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
12/03/2014 159
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) {
;}
}
Commentaires en XML
Csc XmlElement.cs /doc
12/03/2014 160
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 161
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
12/03/2014 162
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);
}
Code ‘unsafe’
unsafe void Foo() {char* buf = stackalloc char[256];for (char* p = buf; p < buf + 256; p++) *p = 0;...
}
12/03/2014 163
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
Avant d’exécuter le code
Lors du chargement
12/03/2014 164
Plan
Introduction Hello World
Objectifs de C#
Types
Structure d’un programme
Instruction
Opérateurs
Utilisation de Visual Studio.NET
Utilisation du SDK
Notions complémentaires 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
12/03/2014 165
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/