SlideShare une entreprise Scribd logo
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érences
vers 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
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; // implicit
short z = (short)x; // explicit
double d = 1.2345678901234;
float f = (float)d; // explicit
long l = (long)d; // explicit
12/03/2014 15
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
MemoryStream FileStream
Stream Hashtable int double
object
12/03/2014 16
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));
12/03/2014 17
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
 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
Types
Unified 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
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;
object o = i;
int j = (int)o;
123i
o
123j
123
System.Int32
12/03/2014 20
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");
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
Signed
sbyte, short,
int, long
Unsigned
byte, 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 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
12/03/2014 31
Predefined Types
Reference Types
Root type object
Character string string
12/03/2014 32
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
C# Type System Type Size (bytes)
object System.Object 0/8 overhead
12/03/2014 33
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()
12/03/2014 34
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
12/03/2014 35
Predefined Types
string
 Normally have to use escape characters
 Verbatim string literals
 Most escape sequences ignored
 Except for “”
 Verbatim literals can be multi-line
string s1= “serverfilesharefilename.cs”;
string s2 = @“serverfilesharefilename.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); // 0
Console.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
20
sp
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 programme
Survol
 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 implicit
N1.C1 b; // Fully qualified name
C2 c; // Error! C2 is undefined
N1.N2.C2 d; // One of the C2 classes
C1.C2 e; // The other one
namespace N1 { // N1
class C1 { // N1.C1
class C2 { // N1.C1.C2
}
}
namespace N2 { // N1.N2
class 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.C1
N2.C1 b; // Refers to N1.N2.C1
12/03/2014 53
Structure d’un programme
Références
 Chaque référence identifie un assemblage
 Utiliser les directives /r ou /reference
dans 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 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
 static void Main()
 static int Main()
 static void Main(string[] args)
 static int Main(string[] args)
12/03/2014 55
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é
 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 block
H();
; // Empty statement
I();
} // End block
}
12/03/2014 60
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; // 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
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!
}
12/03/2014 64
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;
}
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 in
customers.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
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");
}
12/03/2014 72
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;
} } }
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
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
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
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);
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é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
 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érateurs
Pré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é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: %
12/03/2014 81
Opérateurs
Précédence
Category Operators
Additive
Add: +
Subtract: -
Shift
Shift 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érateurs
Précédence
Category Operators
Equality
Equals: ==
Not equals: !=
Bitwise AND &
Bitwise XOR ^
Bitwise OR |
Logical AND &&
Logical OR ||
12/03/2014 83
Opérateurs
Précédence
Category Operators
Ternary conditional ?:
Assignment
=, *=, /=, %=, +=, -=, <<=, >>=,
&=, ^=, |=
12/03/2014 84
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 ‘(‘ …’)’
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();
Interfaces
Example
12/03/2014 98
interface IControl {
void Paint();
}
interface IListBox: IControl {
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {
}
Interfaces
Multiple 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();
}
Interfaces
Explicit 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 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
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 Structures
Différences
12/03/2014 103
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
Classes et Structures
C# 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 Structures
Classes
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 Structures
Structures
12/03/2014 106
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
12/03/2014 107
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
12/03/2014 108
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
 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 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
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 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
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;
//ERROR
public const double s = Math.Sin(Math.PI);
...
}
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
12/03/2014 112
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; } }
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 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
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 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
12/03/2014 115
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
12/03/2014 116
void OutFunction(out int p) {
p = 22;
} int x;
OutFunction(out x);
// x is now 22
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
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 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
 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 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
12/03/2014 119
class Foo {
public void DoSomething(int i) {
...
}
} Foo f = new Foo();
f.DoSomething();
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
12/03/2014 120
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
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 Structures
Méthodes virtuelles
12/03/2014 122
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
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 Structures
Méthodes abstraites
12/03/2014 124
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 Derived: Base { // version 1
public 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 2a
new public virtual void Foo() {
Console.WriteLine("Derived.Foo");
}
}
class Derived: Base { // version 2b
public 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 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()
12/03/2014 126
class Foo {
~Foo() {
Console.WriteLine(“Destroyed {0}”, this);
}
}
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
12/03/2014 127
class Car {
string vid;
public static bool operator ==(Car x, Car y) {
return x.vid == y.vid;
}
}
Classes et Structures
Surcharge d’opérateur
 Opérateur défini par les utilisateurs
 Toujours une méthode statique
12/03/2014 128
Classes et Structures
Surcharge d’opérateur
+ - ! ~
true false ++ --
 Opérateur unaire surchargeable
 Opérateur binaire surchargeable
+ - * / ! ~
% & | ^ == !=
<< >> < > <= >=
12/03/2014 129
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. *=)
12/03/2014 130
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);
}
...
}
12/03/2014 131
class Note {
int value;
// Convert to hertz – no loss of precision
public static implicit operator double(Note x) {
return ...;
}
// Convert to nearest note
public static explicit operator Note(double x) {
return ...;
}
}
Note n = (Note)442.578;
double d = n;
Classes et Structures
Opé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 Structures
Implementation 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 Structures
Implementation des interfaces
 Implémentation explicite des interfaces en
cas de collision des noms
12/03/2014 134
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
12/03/2014 135
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
 Coûteux en temps…
12/03/2014 136
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
12/03/2014 137
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);
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); // Instantiate
double 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
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
}
12/03/2014 142
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
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ènements
Exemple 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 clicked
if (Click != null) Click(this, e);
}
}
12/03/2014 146
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);
}
}
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
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
 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, #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
12/03/2014 155
#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”);
...
}
}
Directives pour le pré processeur
Compilation 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/

Contenu connexe

Tendances

Une introduction à Javascript et ECMAScript 6
Une introduction à Javascript et ECMAScript 6Une introduction à Javascript et ECMAScript 6
Une introduction à Javascript et ECMAScript 6Jean-Baptiste Vigneron
 
Formation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procéduraleFormation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procéduralekemenaran
 
Héritage et polymorphisme- Jihen HEDHLI
Héritage et polymorphisme- Jihen HEDHLIHéritage et polymorphisme- Jihen HEDHLI
Héritage et polymorphisme- Jihen HEDHLIJihenHedhli1
 
Cours c#
Cours c#Cours c#
Cours c#zan
 
Formation C# - Cours 4
Formation C# - Cours 4Formation C# - Cours 4
Formation C# - Cours 4kemenaran
 
Csharp3 heritage-polymorphisme-interface
Csharp3 heritage-polymorphisme-interfaceCsharp3 heritage-polymorphisme-interface
Csharp3 heritage-polymorphisme-interfaceAbdoulaye Dieng
 
Introduction à l’orienté objet en Python
Introduction à l’orienté objet en PythonIntroduction à l’orienté objet en Python
Introduction à l’orienté objet en PythonAbdoulaye Dieng
 
Fondamentaux java
Fondamentaux javaFondamentaux java
Fondamentaux javaInes Ouaz
 
C# - Mappages de types de données SQL Server
C# - Mappages de types de données SQL ServerC# - Mappages de types de données SQL Server
C# - Mappages de types de données SQL ServerMahfoud EL HOUDAIGUI
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfacesAziz Darouichi
 
Dotnet csharp
Dotnet csharpDotnet csharp
Dotnet csharpSDFG5
 
Cpp2 : classes et objets
Cpp2 : classes et objetsCpp2 : classes et objets
Cpp2 : classes et objetsAbdoulaye Dieng
 
Initiation au code : Ateliers en C# (applications desktop et mobile native)
Initiation au code : Ateliers en C# (applications desktop et mobile native)Initiation au code : Ateliers en C# (applications desktop et mobile native)
Initiation au code : Ateliers en C# (applications desktop et mobile native)Stéphanie Hertrich
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objetsAziz Darouichi
 
Csharp2 : classes et objets
Csharp2 : classes et objetsCsharp2 : classes et objets
Csharp2 : classes et objetsAbdoulaye Dieng
 
Chapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphismeChapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphismeAmir Souissi
 
Chapitre 5 classes abstraites et interfaces
Chapitre 5  classes abstraites et interfacesChapitre 5  classes abstraites et interfaces
Chapitre 5 classes abstraites et interfacesAmir Souissi
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateursAziz Darouichi
 
Chapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en JavaChapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en JavaAziz Darouichi
 

Tendances (20)

Une introduction à Javascript et ECMAScript 6
Une introduction à Javascript et ECMAScript 6Une introduction à Javascript et ECMAScript 6
Une introduction à Javascript et ECMAScript 6
 
Formation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procéduraleFormation C# - Cours 2 - Programmation procédurale
Formation C# - Cours 2 - Programmation procédurale
 
Héritage et polymorphisme- Jihen HEDHLI
Héritage et polymorphisme- Jihen HEDHLIHéritage et polymorphisme- Jihen HEDHLI
Héritage et polymorphisme- Jihen HEDHLI
 
Cours c#
Cours c#Cours c#
Cours c#
 
Formation C# - Cours 4
Formation C# - Cours 4Formation C# - Cours 4
Formation C# - Cours 4
 
Polymorphisme
PolymorphismePolymorphisme
Polymorphisme
 
Csharp3 heritage-polymorphisme-interface
Csharp3 heritage-polymorphisme-interfaceCsharp3 heritage-polymorphisme-interface
Csharp3 heritage-polymorphisme-interface
 
Introduction à l’orienté objet en Python
Introduction à l’orienté objet en PythonIntroduction à l’orienté objet en Python
Introduction à l’orienté objet en Python
 
Fondamentaux java
Fondamentaux javaFondamentaux java
Fondamentaux java
 
C# - Mappages de types de données SQL Server
C# - Mappages de types de données SQL ServerC# - Mappages de types de données SQL Server
C# - Mappages de types de données SQL Server
 
Chap 6 : classes et interfaces
Chap 6 : classes et interfacesChap 6 : classes et interfaces
Chap 6 : classes et interfaces
 
Dotnet csharp
Dotnet csharpDotnet csharp
Dotnet csharp
 
Cpp2 : classes et objets
Cpp2 : classes et objetsCpp2 : classes et objets
Cpp2 : classes et objets
 
Initiation au code : Ateliers en C# (applications desktop et mobile native)
Initiation au code : Ateliers en C# (applications desktop et mobile native)Initiation au code : Ateliers en C# (applications desktop et mobile native)
Initiation au code : Ateliers en C# (applications desktop et mobile native)
 
Chapitre5: Classes et objets
Chapitre5: Classes et objetsChapitre5: Classes et objets
Chapitre5: Classes et objets
 
Csharp2 : classes et objets
Csharp2 : classes et objetsCsharp2 : classes et objets
Csharp2 : classes et objets
 
Chapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphismeChapitre 4 heritage et polymorphisme
Chapitre 4 heritage et polymorphisme
 
Chapitre 5 classes abstraites et interfaces
Chapitre 5  classes abstraites et interfacesChapitre 5  classes abstraites et interfaces
Chapitre 5 classes abstraites et interfaces
 
Chapitre6: Surcharge des opérateurs
Chapitre6:  Surcharge des opérateursChapitre6:  Surcharge des opérateurs
Chapitre6: Surcharge des opérateurs
 
Chapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en JavaChapitre 11: Expression Lambda et Référence de méthode en Java
Chapitre 11: Expression Lambda et Référence de méthode en Java
 

En vedette

Principes Relationnels et Concepts Oracle
Principes Relationnelset Concepts OraclePrincipes Relationnelset Concepts Oracle
Principes Relationnels et Concepts Oraclewebreaker
 
Les Contraintes | SQL Oracle
Les Contraintes | SQL OracleLes Contraintes | SQL Oracle
Les Contraintes | SQL Oraclewebreaker
 
Opérateurs Ensemblistes | SQL Oracle
Opérateurs Ensemblistes | SQL OracleOpérateurs Ensemblistes | SQL Oracle
Opérateurs Ensemblistes | SQL Oraclewebreaker
 
Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...
Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...
Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...PMB-BUG
 
SQL Oracle | Regrouper les Données avec les Fonctions de Groupe
SQL Oracle | Regrouper les Données avec les Fonctions de GroupeSQL Oracle | Regrouper les Données avec les Fonctions de Groupe
SQL Oracle | Regrouper les Données avec les Fonctions de Groupewebreaker
 
2009-03-13 SQL Server une plateforme crédible
2009-03-13 SQL Server une plateforme crédible2009-03-13 SQL Server une plateforme crédible
2009-03-13 SQL Server une plateforme crédiblePatrick Guimonet
 
GP Chapitre 2 : Les méthodes de prévision
GP Chapitre 2 : Les méthodes de prévision GP Chapitre 2 : Les méthodes de prévision
GP Chapitre 2 : Les méthodes de prévision ibtissam el hassani
 
Sous-Interrogations - sql oracle
Sous-Interrogations - sql oracleSous-Interrogations - sql oracle
Sous-Interrogations - sql oraclewebreaker
 
Création de Vues | SQL Oracle
Création de Vues | SQL OracleCréation de Vues | SQL Oracle
Création de Vues | SQL Oraclewebreaker
 
Afficher des Données Issues de Plusieurs Tables : SQL Oracle
Afficher des Données Issues de Plusieurs Tables : SQL OracleAfficher des Données Issues de Plusieurs Tables : SQL Oracle
Afficher des Données Issues de Plusieurs Tables : SQL Oraclewebreaker
 
SQL Oracle : Sélection et Tri des Lignes Retournées par un SELECT
SQL Oracle : Sélection et Tri des Lignes Retournées par un SELECTSQL Oracle : Sélection et Tri des Lignes Retournées par un SELECT
SQL Oracle : Sélection et Tri des Lignes Retournées par un SELECTwebreaker
 
Article e-commerce magazine 3-3-2014
Article e-commerce magazine 3-3-2014Article e-commerce magazine 3-3-2014
Article e-commerce magazine 3-3-2014Logicités
 
Favio Nelson Rdriguez grupo 6
Favio Nelson Rdriguez grupo 6Favio Nelson Rdriguez grupo 6
Favio Nelson Rdriguez grupo 6favionelsonr
 
El Proceso Contable I
El Proceso Contable IEl Proceso Contable I
El Proceso Contable Icamaleonon
 

En vedette (20)

Principes Relationnels et Concepts Oracle
Principes Relationnelset Concepts OraclePrincipes Relationnelset Concepts Oracle
Principes Relationnels et Concepts Oracle
 
C# dates and times date formats
C# dates and times  date formatsC# dates and times  date formats
C# dates and times date formats
 
Les Contraintes | SQL Oracle
Les Contraintes | SQL OracleLes Contraintes | SQL Oracle
Les Contraintes | SQL Oracle
 
Opérateurs Ensemblistes | SQL Oracle
Opérateurs Ensemblistes | SQL OracleOpérateurs Ensemblistes | SQL Oracle
Opérateurs Ensemblistes | SQL Oracle
 
Sql
SqlSql
Sql
 
Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...
Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...
Gestion avancée avec PMB: traitement par lots (paniers) et SQL: quelques exem...
 
SQL Oracle | Regrouper les Données avec les Fonctions de Groupe
SQL Oracle | Regrouper les Données avec les Fonctions de GroupeSQL Oracle | Regrouper les Données avec les Fonctions de Groupe
SQL Oracle | Regrouper les Données avec les Fonctions de Groupe
 
2009-03-13 SQL Server une plateforme crédible
2009-03-13 SQL Server une plateforme crédible2009-03-13 SQL Server une plateforme crédible
2009-03-13 SQL Server une plateforme crédible
 
GP Chapitre 2 : Les méthodes de prévision
GP Chapitre 2 : Les méthodes de prévision GP Chapitre 2 : Les méthodes de prévision
GP Chapitre 2 : Les méthodes de prévision
 
Sous-Interrogations - sql oracle
Sous-Interrogations - sql oracleSous-Interrogations - sql oracle
Sous-Interrogations - sql oracle
 
Création de Vues | SQL Oracle
Création de Vues | SQL OracleCréation de Vues | SQL Oracle
Création de Vues | SQL Oracle
 
Afficher des Données Issues de Plusieurs Tables : SQL Oracle
Afficher des Données Issues de Plusieurs Tables : SQL OracleAfficher des Données Issues de Plusieurs Tables : SQL Oracle
Afficher des Données Issues de Plusieurs Tables : SQL Oracle
 
SQL Oracle : Sélection et Tri des Lignes Retournées par un SELECT
SQL Oracle : Sélection et Tri des Lignes Retournées par un SELECTSQL Oracle : Sélection et Tri des Lignes Retournées par un SELECT
SQL Oracle : Sélection et Tri des Lignes Retournées par un SELECT
 
Article e-commerce magazine 3-3-2014
Article e-commerce magazine 3-3-2014Article e-commerce magazine 3-3-2014
Article e-commerce magazine 3-3-2014
 
French
FrenchFrench
French
 
Mene mene tekel upharsin
Mene mene tekel upharsinMene mene tekel upharsin
Mene mene tekel upharsin
 
Projet tice
Projet ticeProjet tice
Projet tice
 
Favio Nelson Rdriguez grupo 6
Favio Nelson Rdriguez grupo 6Favio Nelson Rdriguez grupo 6
Favio Nelson Rdriguez grupo 6
 
Brochure Eskelias
Brochure EskeliasBrochure Eskelias
Brochure Eskelias
 
El Proceso Contable I
El Proceso Contable IEl Proceso Contable I
El Proceso Contable I
 

Similaire à Csharp2014

intro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APPintro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APPfrwebhelp
 
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#MSDEVMTL
 
Interface collectionsinter
Interface collectionsinterInterface collectionsinter
Interface collectionsinterRYMAA
 
Qualité logicielle
Qualité logicielleQualité logicielle
Qualité logiciellecyrilgandon
 
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCSiratiSoufiane
 
10-Cours de Géniel Logiciel
10-Cours de Géniel Logiciel10-Cours de Géniel Logiciel
10-Cours de Géniel Logiciellauraty3204
 
Visual Studio 2008 Overview
Visual Studio 2008 OverviewVisual Studio 2008 Overview
Visual Studio 2008 OverviewGregory Renard
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptxolfaharrabi2
 
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptxESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptxLagloireSouamounou
 
Javascript un langage supérieur
Javascript un langage supérieurJavascript un langage supérieur
Javascript un langage supérieurFredy Fadel
 
Formation python micro club.net
Formation python micro club.netFormation python micro club.net
Formation python micro club.netZakaria SMAHI
 
Patrons de creation
Patrons de creationPatrons de creation
Patrons de creationomri med
 

Similaire à Csharp2014 (20)

intro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APPintro-csharp developement master 2 IF APP
intro-csharp developement master 2 IF APP
 
Qualité de code et bonnes pratiques
Qualité de code et bonnes pratiquesQualité de code et bonnes pratiques
Qualité de code et bonnes pratiques
 
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
Kevin Olivier Avignon: Une introduction à la pensée fonctionnelle avec F#
 
Interface collectionsinter
Interface collectionsinterInterface collectionsinter
Interface collectionsinter
 
Qualité logicielle
Qualité logicielleQualité logicielle
Qualité logicielle
 
Code Complete
Code CompleteCode Complete
Code Complete
 
fortran 2.pdf
fortran 2.pdffortran 2.pdf
fortran 2.pdf
 
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CPP PTT DE CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
 
Modélisation avec UML
Modélisation avec UMLModélisation avec UML
Modélisation avec UML
 
10-Cours de Géniel Logiciel
10-Cours de Géniel Logiciel10-Cours de Géniel Logiciel
10-Cours de Géniel Logiciel
 
Visual Studio 2008 Overview
Visual Studio 2008 OverviewVisual Studio 2008 Overview
Visual Studio 2008 Overview
 
Part1
Part1Part1
Part1
 
POO-chapitre3.pptx
POO-chapitre3.pptxPOO-chapitre3.pptx
POO-chapitre3.pptx
 
Chap 1 Initiation.pptx
Chap 1 Initiation.pptxChap 1 Initiation.pptx
Chap 1 Initiation.pptx
 
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptxESGAE_C#_2021-2024 Cours Avancé (('.pptx
ESGAE_C#_2021-2024 Cours Avancé (('.pptx
 
Introduction à Python
Introduction à PythonIntroduction à Python
Introduction à Python
 
Javascript un langage supérieur
Javascript un langage supérieurJavascript un langage supérieur
Javascript un langage supérieur
 
Formation python micro club.net
Formation python micro club.netFormation python micro club.net
Formation python micro club.net
 
Patrons de creation
Patrons de creationPatrons de creation
Patrons de creation
 
Tour Horizont.Net
Tour Horizont.NetTour Horizont.Net
Tour Horizont.Net
 

Dernier

PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024
PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024
PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024frizzole
 
EL KATRY Reem: Proposition de Programme Artistique et Exposition pour les Écoles
EL KATRY Reem: Proposition de Programme Artistique et Exposition pour les ÉcolesEL KATRY Reem: Proposition de Programme Artistique et Exposition pour les Écoles
EL KATRY Reem: Proposition de Programme Artistique et Exposition pour les ÉcolesSOLIANAEvelyne
 
Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...
Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...
Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...zidani2
 
MARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptx
MARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptxMARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptx
MARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptxMartin M Flynn
 
Webinaire Technologia | DAX : nouvelles fonctions
Webinaire Technologia | DAX : nouvelles fonctionsWebinaire Technologia | DAX : nouvelles fonctions
Webinaire Technologia | DAX : nouvelles fonctionsTechnologia Formation
 
Comment enseigner la langue française en Colombie?
Comment enseigner la langue française en Colombie?Comment enseigner la langue française en Colombie?
Comment enseigner la langue française en Colombie?sashaflor182
 
Gestion des flux de trésorerie dans les entreprises
Gestion des flux de trésorerie dans les entreprisesGestion des flux de trésorerie dans les entreprises
Gestion des flux de trésorerie dans les entreprisesHamdConseil
 
Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...
Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...
Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...Pedago Lu
 
Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...
Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...
Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...Technologia Formation
 
Résultats enquête RH 2024 Fonction Publique.pdf
Résultats enquête RH 2024 Fonction Publique.pdfRésultats enquête RH 2024 Fonction Publique.pdf
Résultats enquête RH 2024 Fonction Publique.pdfGERESO
 
Festival de Cannes 2024.pptx
Festival    de     Cannes        2024.pptxFestival    de     Cannes        2024.pptx
Festival de Cannes 2024.pptxTxaruka
 

Dernier (11)

PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024
PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024
PLANNING HEBDO ET CR LYCEE COUDON 21 MAI2024
 
EL KATRY Reem: Proposition de Programme Artistique et Exposition pour les Écoles
EL KATRY Reem: Proposition de Programme Artistique et Exposition pour les ÉcolesEL KATRY Reem: Proposition de Programme Artistique et Exposition pour les Écoles
EL KATRY Reem: Proposition de Programme Artistique et Exposition pour les Écoles
 
Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...
Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...
Decret-n°19-10-du-23-janvier-2019-reglementant-lexportation-des-déchets-spéci...
 
MARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptx
MARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptxMARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptx
MARTYRS DE TURQUIE – une histoire de persécution chrétienne en Anatolie.pptx
 
Webinaire Technologia | DAX : nouvelles fonctions
Webinaire Technologia | DAX : nouvelles fonctionsWebinaire Technologia | DAX : nouvelles fonctions
Webinaire Technologia | DAX : nouvelles fonctions
 
Comment enseigner la langue française en Colombie?
Comment enseigner la langue française en Colombie?Comment enseigner la langue française en Colombie?
Comment enseigner la langue française en Colombie?
 
Gestion des flux de trésorerie dans les entreprises
Gestion des flux de trésorerie dans les entreprisesGestion des flux de trésorerie dans les entreprises
Gestion des flux de trésorerie dans les entreprises
 
Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...
Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...
Fiche - Accompagnement du travail coopératif au sein d’une équipe d’enseignan...
 
Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...
Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...
Présentation Webinaire Cohésion - Concevoir et mettre en place une CMDB, comm...
 
Résultats enquête RH 2024 Fonction Publique.pdf
Résultats enquête RH 2024 Fonction Publique.pdfRésultats enquête RH 2024 Fonction Publique.pdf
Résultats enquête RH 2024 Fonction Publique.pdf
 
Festival de Cannes 2024.pptx
Festival    de     Cannes        2024.pptxFestival    de     Cannes        2024.pptx
Festival de Cannes 2024.pptx
 

Csharp2014

  • 1. C# Michel RIVEILL riveill@unice.fr - http://www.essi.fr/~riveill Laboratoire I3S Ecole d’Ingénieur en Sciences Informatiques (ESSI)
  • 2. 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
  • 3. 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
  • 4. 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
  • 5. 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
  • 6. 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
  • 7. 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
  • 8. 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
  • 9. 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
  • 10. 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
  • 11. 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érences vers 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. 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
  • 13. 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
  • 14. 12/03/2014 14 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; // implicit short z = (short)x; // explicit double d = 1.2345678901234; float f = (float)d; // explicit long l = (long)d; // explicit
  • 15. 12/03/2014 15 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 MemoryStream FileStream Stream Hashtable int double object
  • 16. 12/03/2014 16 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));
  • 17. 12/03/2014 17 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  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”
  • 18. 12/03/2014 18 Types Unified 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”
  • 19. 12/03/2014 19 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; object o = i; int j = (int)o; 123i o 123j 123 System.Int32
  • 20. 12/03/2014 20 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"); t.Add(2, "two"); string s = string.Format( "Your total was {0} on {1}", total, date);
  • 21. 12/03/2014 21 Types prédéfinis  Valeur  Type entier  Type réel  decimal  bool  char  Référence  object  string Signed sbyte, short, int, long Unsigned byte, ushort, uint, ulong Character char Floating point float, double, decimal Logical bool
  • 22. 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
  • 23. 12/03/2014 30 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
  • 24. 12/03/2014 31 Predefined Types Reference Types Root type object Character string string
  • 25. 12/03/2014 32 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 C# Type System Type Size (bytes) object System.Object 0/8 overhead
  • 26. 12/03/2014 33 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()
  • 27. 12/03/2014 34 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
  • 28. 12/03/2014 35 Predefined Types string  Normally have to use escape characters  Verbatim string literals  Most escape sequences ignored  Except for “”  Verbatim literals can be multi-line string s1= “serverfilesharefilename.cs”; string s2 = @“serverfilesharefilename.cs”;
  • 29. 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
  • 30. 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  …
  • 31. 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); // 0 Console.WriteLine(c.Format()); // Black
  • 32. 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
  • 33. 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);
  • 34. 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
  • 35. 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
  • 36. 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
  • 37. 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
  • 38. 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 20 sp cp 10 20 CPoint
  • 39. 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
  • 40. 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
  • 41. 12/03/2014 48 Structure d’un programme Survol  Organisation des types  Espaces des noms  Références  Méthode principale (main)  Syntaxe
  • 42. 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
  • 43. 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
  • 44. 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 implicit N1.C1 b; // Fully qualified name C2 c; // Error! C2 is undefined N1.N2.C2 d; // One of the C2 classes C1.C2 e; // The other one namespace N1 { // N1 class C1 { // N1.C1 class C2 { // N1.C1.C2 } } namespace N2 { // N1.N2 class C2 { // N1.N2.C2 } } }
  • 45. 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.C1 N2.C1 b; // Refers to N1.N2.C1
  • 46. 12/03/2014 53 Structure d’un programme Références  Chaque référence identifie un assemblage  Utiliser les directives /r ou /reference dans 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
  • 47. 12/03/2014 54 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  static void Main()  static int Main()  static void Main(string[] args)  static int Main(string[] args)
  • 48. 12/03/2014 55 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é  Sauf si préfixé par ‘@’
  • 49. 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
  • 50. 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 }
  • 51. 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
  • 52. 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 block H(); ; // Empty statement I(); } // End block }
  • 53. 12/03/2014 60 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; // Error: can’t hide variable x } }
  • 54. 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 }
  • 55. 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; }
  • 56. 12/03/2014 63 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! }
  • 57. 12/03/2014 64 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; }
  • 58. 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; }
  • 59. 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) { ... }
  • 60. 12/03/2014 67 Instructions for for (int i=0; i < 5; i++) { ... } for (;;) { ... }
  • 61. 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 in customers.OrderBy("name")) { if (c.Orders.Count != 0) { ... } }
  • 62. 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
  • 63. 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)
  • 64. 12/03/2014 71 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"); }
  • 65. 12/03/2014 72 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; } } }
  • 66. 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.
  • 67. 12/03/2014 74 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
  • 68. 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
  • 69. 12/03/2014 76 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);
  • 70. 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
  • 71. 12/03/2014 78 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  Par catégories triées par priorité  À l’intérieur d’une catégorie tous les opérateurs ont la même priorité
  • 72. 12/03/2014 79 Opérateurs Pré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
  • 73. 12/03/2014 80 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: %
  • 74. 12/03/2014 81 Opérateurs Précédence Category Operators Additive Add: + Subtract: - Shift Shift 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
  • 75. 12/03/2014 82 Opérateurs Précédence Category Operators Equality Equals: == Not equals: != Bitwise AND & Bitwise XOR ^ Bitwise OR | Logical AND && Logical OR ||
  • 76. 12/03/2014 83 Opérateurs Précédence Category Operators Ternary conditional ?: Assignment =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
  • 77. 12/03/2014 84 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 ‘(‘ …’)’
  • 78. 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
  • 79. 12/03/2014 86 Using Visual Studio.NET  Types of projects  Console Application  Windows Application  Web Application  Web Service  Windows Service  Class Library  ...
  • 80. 12/03/2014 87 Using Visual Studio.NET  Windows  Solution Explorer  Class View  Properties  Output  Task List  Object Browser  Server Explorer  Toolbox
  • 81. 12/03/2014 88 Using Visual Studio.NET  Building  Debugging  Break points  References  Saving
  • 82. 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
  • 83. 12/03/2014 90 Using .NET Framework SDK  Compiling from command line csc /r:System.WinForms.dll class1.cs file1.cs
  • 84. 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
  • 85. 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
  • 86. 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
  • 87. 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
  • 88. 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
  • 89. 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
  • 90. 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(); Interfaces Example
  • 91. 12/03/2014 98 interface IControl { void Paint(); } interface IListBox: IControl { void SetItems(string[] items); } interface IComboBox: ITextBox, IListBox { } Interfaces Multiple Inheritance  Classes and structs can inherit from multiple interfaces  Interfaces can inherit from multiple interfaces
  • 92. 12/03/2014 99 interface IControl { void Delete(); } interface IListBox: IControl { void Delete(); } interface IComboBox: ITextBox, IListBox { void IControl.Delete(); void IListBox.Delete(); } Interfaces Explicit Interface Members  If two interfaces have the same method name, you can explicitly specify interface + method name to disambiguate their implementations
  • 93. 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
  • 94. 12/03/2014 101 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
  • 95. 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 Structures Différences
  • 96. 12/03/2014 103 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 Classes et Structures C# Structures vs. C++ Structures  Différent des structures C++
  • 97. 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 Structures Classes
  • 98. 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 Structures Structures
  • 99. 12/03/2014 106 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
  • 100. 12/03/2014 107 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
  • 101. 12/03/2014 108 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  L’appel des fonctions virtuellee peut être résolu à la compilation
  • 102. 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 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
  • 103. 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 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
  • 104. 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; //ERROR public const double s = Math.Sin(Math.PI); ... } 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
  • 105. 12/03/2014 112 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; } }
  • 106. 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 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
  • 107. 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 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
  • 108. 12/03/2014 115 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
  • 109. 12/03/2014 116 void OutFunction(out int p) { p = 22; } int x; OutFunction(out x); // x is now 22 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
  • 110. 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 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  Chacune doit avoir une signature unique  La signature est construite uniquement sur les arguments (la valeur de retour est ignorée)
  • 111. 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 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
  • 112. 12/03/2014 119 class Foo { public void DoSomething(int i) { ... } } Foo f = new Foo(); f.DoSomething(); 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
  • 113. 12/03/2014 120 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
  • 114. 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 Structures Méthodes virtuelles
  • 115. 12/03/2014 122 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
  • 116. 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 Structures Méthodes abstraites
  • 117. 12/03/2014 124 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 Derived: Base { // version 1 public 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 2a new public virtual void Foo() { Console.WriteLine("Derived.Foo"); } } class Derived: Base { // version 2b public override void Foo() { base.Foo(); Console.WriteLine("Derived.Foo"); } }
  • 118. 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 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()
  • 119. 12/03/2014 126 class Foo { ~Foo() { Console.WriteLine(“Destroyed {0}”, this); } } 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
  • 120. 12/03/2014 127 class Car { string vid; public static bool operator ==(Car x, Car y) { return x.vid == y.vid; } } Classes et Structures Surcharge d’opérateur  Opérateur défini par les utilisateurs  Toujours une méthode statique
  • 121. 12/03/2014 128 Classes et Structures Surcharge d’opérateur + - ! ~ true false ++ --  Opérateur unaire surchargeable  Opérateur binaire surchargeable + - * / ! ~ % & | ^ == != << >> < > <= >=
  • 122. 12/03/2014 129 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. *=)
  • 123. 12/03/2014 130 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); } ... }
  • 124. 12/03/2014 131 class Note { int value; // Convert to hertz – no loss of precision public static implicit operator double(Note x) { return ...; } // Convert to nearest note public static explicit operator Note(double x) { return ...; } } Note n = (Note)442.578; double d = n; Classes et Structures Opérateur de conversion  Explicite et implicite conversion définies par l’utilisateur
  • 125. 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 Structures Implementation des interfaces  Peuvent implémenter plusieurs interfaces  Doivent implémenter toutes les méthodes de l’interface héritée
  • 126. 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 Structures Implementation des interfaces  Implémentation explicite des interfaces en cas de collision des noms
  • 127. 12/03/2014 134 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
  • 128. 12/03/2014 135 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  Coûteux en temps…
  • 129. 12/03/2014 136 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
  • 130. 12/03/2014 137 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);
  • 131. 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
  • 132. 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); // Instantiate double x = delInst(1.0); // Invoke }
  • 133. 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
  • 134. 12/03/2014 141 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 }
  • 135. 12/03/2014 142 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
  • 136. 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
  • 137. 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
  • 138. 12/03/2014 145 Evènements Exemple 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 clicked if (Click != null) Click(this, e); } }
  • 139. 12/03/2014 146 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); } }
  • 140. 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
  • 141. 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
  • 142. 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) { ... } }
  • 143. 12/03/2014 150 Attributs 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  Quelques uns des attributs prédéfinis du framework .NET
  • 144. 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 ); } }
  • 145. 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
  • 146. 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
  • 147. 12/03/2014 154 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
  • 148. 12/03/2014 155 #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”); ... } } Directives pour le pré processeur Compilation conditionnelle
  • 149. 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
  • 150. 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
  • 151. 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
  • 152. 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
  • 153. 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
  • 154. 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
  • 155. 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; ... }
  • 156. 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
  • 157. 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
  • 158. 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/