C

1
C

• Michel RIVEILL
• riveill_at_unice.fr - http//www.essi.fr/riveill
• Laboratoire I3S
• Ecole dIngénieur en Sciences Informatiques (ESSI)

2
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

3
Hello World
using System class Hello static void Main(
) Console.WriteLine("Hello
world") Console.ReadLine() // Hit enter to
finish
csc HelloWorld.cs /referenceSystem.Windows.Forms.
dll
4
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

5
COrienté 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 dun langage
• Celui qui écrit un composant, ne connaît pas
  celui qui va lutiliser (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 à
  lexécution
• Génération de documentation au format XML
• Programmation en une étape
• Pas de fichiers dentête (.h), de description
  IDL, etc.
• Peut être embarqué dans des pages ASP

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 à lexécution
• C unifie les deux approches, avec de bonne
  performance
• Simplicité utilisée partout dans le framework
• Augmente lextensibilité et la réutilisabilité
• Nouveaux types primitifs Décimal, SQL
• Collections, etc., fonctionnent pour tous les
  types

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 derreur

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
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

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
• Dautres 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
• lensemble forme une hiérarchie
• Il y a 2 catégories de types valeur et référence

11
Types Un seul système de type

• Type valeur
• Contient des données
• Ne peut être null
• Primitives int i float x
• Enumératios enum State Off, On
• Structures struct Point int x,y
• Type référence
• Contient des référencesvers des objets
• Peut être null
• Racine object
• Chaîne string
• Classes class Foo Bar, IFoo ...
• Interfaces interface IFoo IBar ...
• Tableau string a new string10
• Delegates delegate void Empty()

int i 123 string s "Hello world"
12
Types Un seul système de type
13
Types Un seul système de type

• Bénéfice des types valeurs
• Pas dallocation 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
TypesConversions

• Conversion implicite
• Fonctionne automatiquement et sans possibilité
  déchec
• Pas de perte de précision/dinformation
• Conversion explicite
• Nécessite un cast
• Peu être refusée
• De linformation/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
TypesUn système de type unifié

• Tout est objet
• Tous les types héritent du type objet
• Toute donnée peut être sauvegardée, échangée et
  manipulée de la même manière

16
TypesUn système de type unifié

• Polymorphisme
• Capacité deffectuer une opération sur un objet
  sans connaître le type précis de lobjet (et donc
  le code qui sera réellement exécuter)
• Sappuie sur les interfaces de objets et sur les
  relations de conformité entre les types

void Poly(object o) Console.WriteLine(o.ToStri
ng())
Poly(42) Poly(abcd) Poly(12.345678901234m) Po
ly(new Point(23,45))
17
TypesUn système de type unifié

• Question Comment peut-on traiter les valeur et
  les références de la même manière ?
• Comment un int (type valeur) peut être converti
  en un objet (type référence) ?
• Réponse Boxing!
• Seulement les types valeurs peuvent être boxed
  (encapsulé)
• Les types références nont 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 dun type référence est interprétée
  comme une copie du type valeur
• Les types valeurs nont jamais de synonyme
  (dalias)
• Un type valeur est converti de manière implicite
  dans un type référence (objet)
• up cast

18
TypesUnified Type System

• Unboxing
• Inverse operation of boxing
• Copies the value out of the box
• Copies from reference type to value type
• Requires an explicit conversion
• May not succeed (like all explicit conversions)
• Essentially a down cast

19
TypesUn système de type unifié

• Unboxing
• Opération inverse du boxing
• Extrait la valeur de la boite
• Copies depuis une référence type to value type
• Requiert une conversion explicite
• Peut ne pas être acceptée (comme toute les autres
  conversions explicites)
• down cast
• Boxing et unboxing

123
i
int i 123 object o i int j (int)o
System.Int32
o
123
123
j
20
TypesUn système de type unifié

• Benefice du boxing
• Permet le polymorphisme pour tous les types (y
  compris les types valeurs)
• Les classes collections fonctionnent avec tous
  les types
• Elimine la nécessité de construire manuellement
  des classes dencapsulation
• On trouve plein dexemple dutilisation 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
Types prédéfinis

• Valeur
• Type entier
• Type réel
• decimal
• bool
• char
• Référence
• object
• string

22
Types prédéfinis
23
Types prédéfinis Floating Point Types

• Follows IEEE 754 specification
• Supports 0, Infinity, NaN

24
Predefined Typesdecimal

• 128 bits
• Essentially a 96 bit value scaled by a power of
  10
• Decimal values represented precisely
• Doesnt support signed zeros, infinities or NaN

25
Predefined Typesdecimal

• All integer types can be implicitly converted to
  a decimal type
• Conversions between decimal and floating types
  require explicit conversion due to possible loss
  of precision
• s m 10e
• s 1 or 1
• 0 ? m ? 296
• -28 ? e ? 0

26
Predefined TypesIntegral Literals

• Integer literals can be expressed as decimal or
  hexadecimal
• U or u uint or ulong
• L or l long or ulong
• UL or ul ulong

123 // Decimal 0x7B //
Hexadecimal 123U // Unsigned 123ul
// Unsigned long 123L // Long
27
Predefined TypesReal Literals

• F or f float
• D or d double
• M or m decimal

123f // Float 123D //
Double 123.456m // Decimal 1.23e2f
// Float 12.3E1M // Decimal
28
Predefined Typesbool

• Represents logical values
• Literal values are true and false
• Cannot use 1 and 0 as boolean values
• No standard conversion between other types and
  bool

29
Predefined Typeschar

• Represents a Unicode character
• Literals
• A // Simple character
• \u0041 // Unicode
• \x0041 // Unsigned short hexadecimal
• \n // Escape sequence character

30
Predefined Typeschar

• Escape sequence characters (partial list)

31
Predefined TypesReference Types
32
Predefined Typesobject

• Root of object hierarchy
• Storage (book keeping) overhead
• 0 bytes for value types
• 8 bytes for reference types
• An actual reference (not the object) uses 4 bytes

33
Predefined Typesobject Public Methods

• public bool Equals(object)
• protected void Finalize()
• public int GetHashCode()
• public System.Type GetType()
• protected object MemberwiseClone()
• public void Object()
• public string ToString()

34
Predefined Typesstring

• An immutable sequence of Unicode characters
• Reference type
• Special syntax for literals
• string s I am a string

35
Predefined Typesstring

• Normally have to use escape characters
• Verbatim string literals
• Most escape sequences ignored
• Except for
• Verbatim literals can be multi-line

string s1 \\\\server\\fileshare\\filename.cs
string s2 _at_\\server\fileshare\filename.cs
36
Types

• Types définis par lutilisateur

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

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
39
Types Arrays

• Un tableau permet à un groupe déléments dun
  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

40
Types Arrays

• Déclaration
• Allocation
• Initialisation
• Accès
• Enumération

int primes
int primes new int9
int prime new int 1,2,3,5,7,11,13,17,19
int prime 1,2,3,5,7,11,13,17,19
prime2i primei
foreach (int i in prime) Console.WriteLine(i)
41
Types Arrays

• Tableau multidimensional
• Régulier
• int, matR new int2,3
• Il peut être initialisé de manière
  déclarativeint, matR new int2,3
  1,2,3, 4,5,6
• Irrégulier
• Un tableau de tableaux
• int matJ new int2
• Doit être initialisé par programme

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 dimplémentation
• Elle doit être implémenté par une classe ou une
  structure

43
Types Classes

• Type référence défini par lutilisateur
• 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 daccès
• public, protected, private, internal, protected
  internal
• Le mode par défaut est private
• Instantancié par lopérateur new

44
Types Structs

• Similaire aux classes, mais
• Type valeur défini par lutilisateur
• Hérite toujours dobjet
• Ideal pour des objets légers
• int, float, double, etc., sont des structures
• Permet la définition de type primitifs par
  lutilisateur
• Complex, point, rectangle, color, rational
• Héritage multiple des interfaces
• Même membres que les classes
• Contrôle daccès
• public, internal, private
• Instancié par lopérateur new

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
sp
20
cp
CPoint
10
20
46
Types Delegates

• Un délégué (delegate) est un type référence qui
  défini la signature dune 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

47
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

48
Structure dun programmeSurvol

• Organisation des types
• Espaces des noms
• Références
• Méthode principale (main)
• Syntaxe

49
Structure dun 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 dordre 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

50
Structure dun programme Espaces de noms

• Un nom de type doit être unique au sein dun
  espace de nom (Namespace)
• Permet lorganisation logique des types
• Il ny 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 dun type par son nom qualifié
  implique linclusion de tout lespace de nom dans
  lequel il est défini

51
Structure dun programme Espaces de noms
namespace N1     // N1 class C1    //
N1.C1 class C2    // N1.C1.C2    
    namespace N2     // N1.N2 class C2
// N1.N2.C2        

• Il est toujours possible dutiliser le nom
  qualifié
• La directive using permet de sen 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
52
Structure dun 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
53
Structure dun programmeRéférences

• Chaque référence identifie un assemblage
• Utiliser les directives /r ou /reference dans le
  compilateur C
• Lespace 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 /referenceSystem.WinForms.dll
54
Structure dun programmeMéthode Main

• Léxecution dun 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)

55
Structure dun programmeSyntaxe

• Identificateurs
• Noms pour les types, les méthodes, les champs,
  etc.
• Un seul mot sans espace
• Caractère Unicode
• Le premier caractère est soit une lettre soit _
• Sensible à la casse
• Ne doit pas être un mot clé
• Sauf si préfixé par _at_

56
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

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 cest nouveau
• Les expressions ne peuvent pas être utilisée à la
  place des instructions

void Foo() i 1 // error
58
Instructions Survol

• Expressions
• checked, unchecked
• lock
• using
• Conditionnels
• if
• Switch
• Boucles
• while
• do
• for
• foreach
• Sauts
• break
• continue
• goto
• return
• throw
• Exceptions

59
Instructions syntaxe
static void Main() F() G() //
Start block H() // Empty
statement I() // End block

• Instructions terminéespar
• Bloc dinstruction ... ne nécessitepas
  de
• Commentaires
• // commentaire sur une seule ligne
• / Commentaire sur
  plusieurs lignes/

60
IntructionsVariables et constantes
static void Main() const float pi 3.14f
const int r 123 Console.WriteLine(pi r
r) int a int b 2, c 3 a 1
Console.WriteLine(a b c)

• Règle de portée des déclarations usuelles
• Mais impossibilité de redéfinir une variable à
  lintérieur dun bloc

int x int x // Error cant hide
variable x
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
• Linitialisation 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
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 lt values.GetLength(0) i)
for (j 0 j lt values.GetLength(1) j)
if (valuesi, j value) goto found
throw new InvalidOperationException(Not
found") found row i col j
63
InstructionsExpression

• Affectation, appel de méthode, , --, new

static void Main() int a, b 2, c 3 a
b c a MyClass.Foo(a,b,c)
Console.WriteLine(a b c) a 2 //
ERROR!
64
instructionsif

• if (expression booléenne)

int Test(int a, int b) if (a gt b) return
1 else if (a lt b) return -1 else
return 0
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
66
Instructions while

• La aussi il faut une expression booléenne

int i 0 while (i lt 5) ... i
int i 0 do ... i while (i lt 5)
while (true) ...
67
Instructions for
for (int i0 i lt 5 i) ...
for () ...
68
Instructions foreach

• Permet de parcourir un tableau
• Permet de parcourir une collection
• Implémenté par linterface 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) ...
69
Instructions Sauts

• break
• Termine la boucle
• continue
• Termine litération de la boucle en cours
• goto ltlabelgt
• Transfert lexécution au label
• return ltexpressiongt
• Termine la méthode
• throw
• Lève une exception

70
Instructions Exception

• Une exception est une instance de la classe
  System.Exception ou dune classe dérivée
• Contient des informations à propos de lexception
• Propriétés
• Message
• StackTrace
• InnerException
• try...catch...finally
• try permet de lever une exception
• catch permet de traiter les exceptions
• Il est possible davoir plusieurs bloc catch pour
  différentes exceptions
• finally contient le code qui doit toujours être
  executé
• Il nest pas possible de sortir dun bloc finally
  par un saut (e.g. goto)

71
InstructionsException

• Il est possible de relever la même exception ou
  de la capturer (bloc catch) pour en lever une
  autre

try Console.WriteLine("try") throw new
Exception(message) catch (ArgumentNullExcepti
on e) Console.WriteLine(caught null
argument") catch Console.WriteLine("catch")
finally Console.WriteLine("finally")
72
instructionsSynchronisation

• Lock
• Mutuelle exclusion
• Mis en oeuvre à laide 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
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 lexécution des destructeurs
• Les objects qui nécessitent dêtre nettoyer lors
  de leur destruction doivent implémenter
  linterface System.IDisposable
• Méthode Dispose()
• Linstruction using permet de créer une instance,
  de lutiliser et de la détruire en étant certain
  que la méthode Dispose soit appelée à la fin de
  linstruction.

74
Statementsusing Statement
public class MyResource IDisposable public
void MyResource() // Acquire valuble
resource public void Dispose() //
Release valuble resource public void
DoSomething() ...
using (MyResource r new MyResource())
r.DoSomething() // r.Dispose() is called
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 dinstruction
• Le mode par défaut est unchecked
• Lutilisation de la directive /checked du
  compilateur permet dutiliser le mode checked par
  défaut

76
InstructionsEntrée / sortie

• Entrée/sortie console
• System.Console.WriteLine()
• System.Console.ReadLine()
• Appel windows
• System.WinForms.MessageBox.Show()

string v1 some value MyObject v2 new
MyObject() Console.WriteLine(First is 0,
second is 1, v1, v2)
77
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

78
OpérateursSurvol

• C défini un ensemble dopé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é
• À lintérieur dune catégorie tous les opérateurs
  ont la même priorité

79
Opérateurs Précédence
80
Opérateurs Précédence
81
Opérateurs Précédence
82
Opérateurs Précédence
83
Opérateurs Précédence
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 ( )

85
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

86
Using Visual Studio.NET

• Types of projects
• Console Application
• Windows Application
• Web Application
• Web Service
• Windows Service
• Class Library
• ...

87
Using Visual Studio.NET

• Windows
• Solution Explorer
• Class View
• Properties
• Output
• Task List
• Object Browser
• Server Explorer
• Toolbox

88
Using Visual Studio.NET

• Building
• Debugging
• Break points
• References
• Saving

89
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

90
Using .NET Framework SDK

• Compiling from command line

csc /rSystem.WinForms.dll class1.cs file1.cs
91
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

92
Review Key Object-Oriented Concepts

• Objects, instances and classes
• Identity
• Every instance has a unique identity, regardless
  of its data
• Encapsulation
• Data and function are packaged together
• Information hiding
• An object is an abstraction
• User should NOT know implementation details

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

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

95
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

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

97
InterfacesExample
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()
98
InterfacesMultiple Inheritance

• Classes and structs can inherit from multiple
  interfaces
• Interfaces can inherit from multiple interfaces

interface IControl void Paint() interface
IListBox IControl void SetItems(string
items) interface IComboBox ITextBox, IListBox

99
InterfacesExplicit Interface Members

• If two interfaces have the same method name, you
  can explicitly specify interface method name to
  disambiguate their implementations

interface IControl void Delete() interface
IListBox IControl void Delete() interface
IComboBox ITextBox, IListBox void
IControl.Delete() void IListBox.Delete()
100
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

101
Classes et StructuresSimilarités

• Chacune
• Est un type défini par lutilisateur
• 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

102
Classes et StructuresDifférences
103
Classes et StructuresC Structures vs. C
Structures

• Différent des structures C

104
Classes et StructuresClasses
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(
)
105
Classes et StructuresStructures
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
106
Classes et StructuresStatic vs. Instance

• Par défaut, les variables sont créées par
  instance
• Chaque instance a ses propres champs
• Les méthodes sont appliquées à une instance
• Les variables statiques sont associées à des
  types
• Les méthodes statique ne peuvent pas accéder aux
  données de linstance
• 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

107
Classes and StructsDirectives daccès

• Les directives daccès permettent de spécifier
  qui peut utiliser un type ou un membre
• Les directives daccès permettent de contrôler
  lencapsulation
• 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

108
Classes et StructuresClasses abstraites et
classes finales

• Une classe abstraite ne peut pas être instantiée
• Prévue pour être utilisée comme une classe de
  base
• Peuvent contenir des fonctions membres abstraites
  et non abstraites
• Similaire à une interface
• Ne peut être finale (sealed)

• Une classe finale (sealed) ne peut être utilisé
  comme une classe de base
• Une classe finale ne peut être abstraite
• Une structure est implicitement finale
• Pourquoi des classes finales ?
• Pour empêcher une dérivation non souhaitée
• Pour optimiser le code
• Lappel des fonctions virtuellee peut être résolu
  à la compilation

109
Classes et Structuresthis

• Le mot clé this est une variable prédéfinie
  accessible dans chaque fonction membre non
  statique
• Utilisé pour supprimer les ambiguïtés lors de
  laccès aux données ou aux fonctions membres

class Person string name public
Person(string name) this.name name
public void Introduce(Person p) if (p !
this) Console.WriteLine(Hi, Im
name)
110
Classes et Structuresbase

• Le mot clé base est utilisé pour accéder aux
  membres de classes masqués par un nom similaire
  de la classe courante

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
111
Classes et StructuresConstantes

• Une constante est une donnée membre qui est
  évaluée à la compilation
• Elle est implicitement statique
• i.e. Math.PI

public class MyClass public const string
version 1.0.0 public const string s1
abc def public const int i3 1 2
public const double PI_I3 i3 Math.PI
//ERROR public const double s
Math.Sin(Math.PI) ...
112
Classes et StructuresChamps non modifiable
(read-only)

• Similaire à une constante, mais initialisé à
  lexécution
• Une fois initiatisé, il ne plus être modifié
• Différents à une constante
• Initialisé à lexécution (vs. à la compilation)
• Il nest 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

113
Classes et StructuresPropriétés

• Une propriété est un champ virtuel
• Ressemble à un champ, mais est implémenté par du
  code
• Peut être read-only, write-only ou read/write

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
114
Classes et StructuresIndexeurs

• Un indexeur permet à une instance dêtre un
  tableau virtuel
• Peut être surchargé (i.e. indexé par int et par
  string)
• Peut être read-only, write-only ou read/write

public class ListBox Control private
string items public string thisint index
get return itemsindex set
itemsindex value Repaint()

ListBox listBox new ListBox() listBox0
"hello" Console.WriteLine(listBox0)
115
Classes et StructuresMéthodes

• Tout code est exécuté par une méthode
• Constructeurs, destructeurs et operateurs sont
  des types particuliers de méthodes
• Propriétés et indexeurs sont implémentés par des
  méthodes get/set
• Une méthode peut recevoir des paramètres
• Passage par valeur
• Ou par référence ref (dans la signature de la
  méthode et dans lappel)
• Permet à une méthode de modifier la variable
• La variable doit avoir une valeur avant lappel

void RefFunction(ref int p) p
int x 10 RefFunction(ref x) // x is now 11
116
Classes et StructuresMéthodes

• Une méthode peut recevoir des paramètres (suite)
• Et avoir des paramètres retours
• out (dans la signature de la méthode et dans
  lappel)
• La méthode doit initialiser largument avant de
  terminer
• Et des paramètres résultats

void OutFunction(out int p) p 22
int x OutFunction(out x) // x is now 22
117
Classes et StructuresSurcharge des méthodes

• Il est possible de surcharger le type dune
  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)

void Print(int i) void Print(string s) void
Print(char c) void Print(float f) // Error
duplicate signature int Print(float f)
118
Classes et StructuresParamètres variables

• Une méthode peut avoir un nombre variable de
  paramètres
• Déclaré par le mots clé params
• Doit être le dernier argument

int Sum(params int intArr) int sum 0
foreach (int i in intArr) sum i return
sum
int sum Sum(13,87,34)
119
Classes et StructuresMéthodes non-virtuelles

• Méthodes non-virtuelles par défaut
• Ne sont pas polymorphes
• Elles ne peuvent pas être surchargées
• Elles ne peuvent pas être abstraites

class Foo public void DoSomething(int i)
...
Foo f new Foo() f.DoSomething()
120
Classes et StructuresMéthodes virtuelles

• Définie dans une classe de base
• Peuvent être surchargées dans une classe dérivée
• Chaque classe fourni sa propre implémentation de
  la méthode
• Peut contenir une implémentation par défaut
• Si lon 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

121
Classes et StructuresMéthodes virtuelles
class Shape public virtual void Draw() ...
class Box Shape public override void
Draw() ... class Sphere Shape public
override void Draw() ...
void HandleShape(Shape s) s.Draw() ...
HandleShape(new Box()) HandleShape(new
Sphere()) HandleShape(new Shape())
122
Classes et StructuresMéthodes abstraites

• une méthode abstraite est une méthode virtuelle
  qui na pas dimplémentation
• Doit être dans une classe abstraite
• Doit être implémentée dans une classe dérivée

123
Classes et StructuresMéthodes abstraites
abstract class Shape public abstract void
Draw() class Box Shape public override
void Draw() ... class Sphere Shape
public override void Draw() ...
void HandleShape(Shape s) s.Draw() ...
HandleShape(new Box()) HandleShape(new
Sphere()) HandleShape(new Shape()) // Error!
124
Classes et StructuresSurcharge de méthode

• La surcharge doit être explicite override ou
  new
• Supprimer les surcharges accidentelle
• Les méthodes sont non virtuelles par défaut

class Base // version
1
class Base // version 2
public virtual void Foo()
Console.WriteLine("Base.Foo")
class Derived Base // version 1
public virtual void Foo()
Console.WriteLine("Derived.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")
125
Classes et StructuresConstructeurs

• Un constructeur peut en appeler un autre
• this(...) dans la même classe
• base(...) pour la classe de base
• Le constructeur par défaut est base()

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
126
Classes et StructuresDestructeurs

• Un destructeur est une méthode appelé par lors de
  la destruction de lobjet (par GC)
• Permet déliminer les objets liés
• Les structures ne peuvent pas avoir de
  destructeurs

class Foo Foo() Console.WriteLine(De
stroyed 0, this)
127
Classes et StructuresSurcharge dopérateur

• Opérateur défini par les utilisateurs
• Toujours une méthode statique

class Car string vid public static bool
operator (Car x, Car y) return x.vid
y.vid
128
Classes et StructuresSurcharge dopérateur

• Opérateur unaire surchargeable

• Opérateur binaire surchargeable

129
Classes et StructuresSurcharge dopé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 dun opérateur binaire (e.g. )
  surcharge implicitement lopérateur daffectation
  correspondant (e.g. )

130
Classes et StructuresSurcharge dopé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) ...
131
Classes et StructuresOpérateur de conversion

• Explicite et implicite conversion définies par
  lutilisateur

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
132
Classes et StructuresImplementation des
interfaces

• Peuvent implémenter plusieurs interfaces
• Doivent implémenter toutes les méthodes de
  linterface héritée

public interface IDelete void
Delete() public class TextBox IDelete
public void Delete() ... public class Car
IDelete public void Delete() ...
TextBox tb new TextBox() IDelete iDel
tb iDel.Delete() Car c new Car() iDel
c iDel.Delete()
133
Classes et StructuresImplementation des
interfaces

• Implémentation explicite des interfaces en cas de
  collision des noms

public interface IDelete void
Delete() public interface IFoo void
Delete() public class TextBox IDelete, IFoo
public void IDelete.Delete() ... public
void IFoo.Delete() ...
134
Classes et StructuresType interne

• Déclaré à linterieur dun 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 à lextérieur du type
  qui le défini

135
Classes et Structuresis

• Lopérateur is permet de tester à lexécution le
  type dun objet

static void DoSomething(object o) if (o is
Car) ((Car)o).Drive()

• A utiliser avec modération
• Coûteux en temps

136
Classes et Structures as

• Lopérateur as converti une variable (si cest
  possible) dans le type demandé
• Si ce nest 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

137
Classes et Structures typeof

• Lopérateur typeof retourne le type de lobjet
  désigné (appel de System.Type)
• Utilise la réflexion pour obtenir dynamiquement
  le type

Console.WriteLine(typeof(int).FullName) Console.W
riteLine(typeof(System.Int).Name) Console.WriteLi
ne(typeof(float).Module) Console.WriteLine(typeof
(double).IsPublic) Console.WriteLine(typeof(Car).
MemberType)
138
Plan

• Introduction
• Hello World
• Objectifs de C
• Types
• Structure dun 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

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
• Cest 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
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 dappel
• Les méthodes sont appelées séquentiellement, dans
  leur ordre dajout
• Opérateurs et -
• Utilisés pour insérer supprimer une méthode à la
  liste du delegate
• Fonctionnent correctement avec les threads

141
DelegatesMulticast Delegates
delegate void SomeEvent(int x, int y) static
void Foo1(int x, int y) Console.WriteLine("Foo
1") 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
142
Delegateset interfaces

• Il est toujours possible dutiliser des
  interfaces à la place des delegates
• Interfaces sont plus puissantes