Csharp2014

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
 Instruction
 Opérateurs
 Interfaces
 Classes et Structures
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Classes and Structures
 Delegates
 Events
 Attributs
 Code Unsafe

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
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
 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
 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
 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
 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
 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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
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
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
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
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
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
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
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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
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
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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Windows
 Solution Explorer
 Class View
 Properties
 Output
 Task List
 Object Browser
 Server Explorer
 Toolbox

12/03/2014 88
 Building
 Debugging
 Break points
 References
 Saving

12/03/2014 89
Plan
 Introduction
 Hello World
 Objectifs de C#
 Types
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 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
 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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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 {
}
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
 Instruction
 Opérateurs
 Interfaces
 Classes et structures
 Delegates
 Events
 Attributs
 Code Unsafe

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
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
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

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
Structures

12/03/2014 106
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 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);
}
}
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;
}
}
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);
...
}
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
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;
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]);
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
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
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);
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);
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();
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
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 {
}
void HandleShape(Shape s) {
s.Draw();
...
} HandleShape(new Box());
HandleShape(new Sphere());
HandleShape(new Shape());
Méthodes virtuelles

12/03/2014 122
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 {
}
class Sphere : Shape {
}
void HandleShape(Shape s) {
s.Draw();
...
}
HandleShape(new Box());
HandleShape(new Sphere());
HandleShape(new Shape()); // Error!
Méthodes abstraites

12/03/2014 124
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() {
}
}
class Derived: Base { // version 2b
public override void Foo() {
base.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; }
}
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);
}
}
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;
}
}
Surcharge d’opérateur
 Opérateur défini par les utilisateurs
 Toujours une méthode statique

12/03/2014 128
+ - ! ~
true false ++ --
 Opérateur unaire surchargeable
 Opérateur binaire surchargeable
+ - * / ! ~
% & | ^ == !=
<< >> < > <= >=

12/03/2014 129
 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
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;
Opérateur de conversion
 Explicite et implicite conversion définies par
l’utilisateur

12/03/2014 132
void Delete();
}
public class TextBox : IDelete {
}
public class Car : IDelete {
}
TextBox tb = new TextBox();
IDelete iDel = tb;
iDel.Delete();
Car c = new Car();
iDel = c;
iDel.Delete();
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
void Delete();
}
public interface IFoo {
void Delete();
}
public class TextBox : IDelete, IFoo {
public void IDelete.Delete() { ... }
public void IFoo.Delete() { ... }
}
Implementation des interfaces
 Implémentation explicite des interfaces en
cas de collision des noms

12/03/2014 134
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
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
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
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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Evénements
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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
 Instruction
 Opérateurs
 Interfaces
 Delegates
 Events
 Attributs
 Code Unsafe

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/

Csharp2014

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Csharp2014

Similaire à Csharp2014 (20)

Dernier

Dernier (20)

Csharp2014