Csharp2014

C#

Michel RIVEILL

[email protected] - http://www.essi.fr/~riveill

Laboratoire I3S

Ecole d’Ingénieur en Sciences Informatiques (ESSI)

mailto:[email protected]

http://www.essi.fr/~riveill

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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces

Classes et Structures

Delegates

Events

Attributs


Commentaires en XML

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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces

Classes and Structures

Delegates

Events

Attributs


Commentaires en XML

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érencesvers des objets

Peut être ‘null’

Racine object Chaîne string Classes class Foo: Bar, IFoo {...} Interfaces interface IFoo: IBar {...} Tableau string[] a = new string[10]; Delegates delegate void Empty();

int i = 123;string s = "Hello world";

123i

s "Hello world"

12/03/2014 12


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


Bénéfice des types valeurs

Pas d’allocation dans le tas, moins de travail

pour le GC

Meilleure utilisation de la mémoire

Moins de référence indirecte

Un seul système de type

Pas de dichotomie type primitif/objet

12/03/2014 14

TypesConversions

Conversion implicite

Fonctionne automatiquement et sans possibilité d’échec

Pas de perte de précision/d’information

Conversion explicite

Nécessite un ‘cast’

Peu être refusée

De l’information/précision peut être perdue

Conversion implicite et explicite sont précisées par le programmeur

int x = 123456;long y = x; // implicitshort z = (short)x; // explicit

double d = 1.2345678901234;float f = (float)d; // explicitlong l = (long)d; // explicit

12/03/2014 15

TypesUn système de type unifié

Tout est objet

Tous les types héritent du type objet

Toute donnée peut être sauvegardée,

échangée et manipulée de la même manière

MemoryStream FileStream

Stream Hashtable int double

object

12/03/2014 16


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


Question : Comment peut-on traiter les valeur et les références de la même manière ? Comment un int (type valeur) peut être converti en un objet (type

référence) ?

Réponse : Boxing! Seulement les types valeurs peuvent être ‘boxed’ (encapsulé)

Les types références n’ont pas à être ‘boxed’

Boxing Copie un type valeur dans un type référence (objet)

Chaque type valeur à une correspondance “cachée” dans un type référence

Une copie d’un type référence est interprétée comme une copie du type valeur Les types valeurs n’ont jamais de synonyme (d’alias)

Un type valeur est converti de manière implicite dans un type référence (objet) “up cast”

12/03/2014 18

TypesUnified Type System

Unboxing

Inverse operation of boxing

Copies the value out of the box

Copies from reference type to value type

Requires an explicit conversion

May not succeed (like all explicit conversions)

Essentially a “down cast”

12/03/2014 19


Unboxing

Opération inverse du boxing

Extrait la valeur de la ‘boite’

Copies depuis une référence type to value type

Requiert une conversion explicite

Peut ne pas être acceptée (comme toute les autres

conversions explicites)

“down cast”

Boxing et unboxing

int i = 123;

object o = i;

int j = (int)o;

123i

o

123j123

System.Int32

12/03/2014 20


Benefice du boxing

Permet le polymorphisme pour tous les types (y compris les types

valeurs)

Les classes ‘collections’ fonctionnent avec tous les types

Elimine la nécessité de construire manuellement des classes

d’encapsulation

On trouve plein d’exemple d’utilisation dans le Framework .NET

Désavantage du boxing

Performance

La nécessité du boxing est moindre quand le CLR supportera la

généricité (C++ templates)

Hashtable t = new Hashtable();t.Add(0, "zero");t.Add(1, "one");t.Add(2, "two");

string s = string.Format("Your total was {0} on {1}", total, date);

12/03/2014 21

Types prédéfinis

Valeur

Type entier

Type réel

decimal

bool

char

Référence

object

string

Signedsbyte, short, int, long

Unsignedbyte, ushort, uint, ulong

Character char

Floating

point

float, double, decimal

Logical bool

12/03/2014 22

Types prédéfinis

C# Type System Type Size (bytes) Signed?

sbyte System.Sbyte 1 Yes

short System.Int16 2 Yes

int System.Int32 4 Yes

long System.Int64 8 Yes

byte System.Byte 1 No

ushort System.UInt16 2 No

uint System.UInt32 4 No

ulong System.UInt64 8 No

12/03/2014 30

Predefined Typeschar

Escape sequence characters (partial list)

Char Meaning Value

\’ Single quote 0x0027

\” Double quote 0x0022

\\ Backslash 0x005C

\0 Null 0x0000

\n New line 0x000A

\r Carriage return 0x000D

\t Tab 0x0009

12/03/2014 31

Predefined TypesReference Types

Root type object

Character string string

12/03/2014 32

Predefined Typesobject

Root of object hierarchy

Storage (book keeping) overhead

0 bytes for value types

8 bytes for reference types

An actual reference (not the object)

uses 4 bytes

C# Type System Type Size (bytes)

object System.Object 0/8 overhead

12/03/2014 33

Predefined Typesobject Public Methods

public bool Equals(object)

protected void Finalize()

public int GetHashCode()

public System.Type GetType()

protected object MemberwiseClone()

public void Object()

public string ToString()

12/03/2014 34

Predefined Typesstring

An immutable sequence of Unicode

characters

Reference type

Special syntax for literals

string s = “I am a string”;

C# Type System Type Size (bytes)

String System.String 20 minimum

12/03/2014 35

Predefined Typesstring

Normally have to use escape characters

Verbatim string literals

Most escape sequences ignored

Except for “”

Verbatim literals can be multi-line

string s1= “\\\\server\\fileshare\\filename.cs”;

string s2 = @“\\server\fileshare\filename.cs”;

12/03/2014 36

Types

Types définis par l’utilisateur

Enumerations enum

Arrays int[], string[]

Interface interface

Reference type class

Value type struct

Function pointer delegate

12/03/2014 37

Types Enums

An enum defines a type name for a related group of symbolic constants

Choices must be known at compile-time

Strongly typed

No implicit conversions to/from int

Can be explicitly converted

Operators: +, -, ++, --, &, |, ^, ~, …

Can specify underlying type

byte, sbyte, short, ushort, int, uint, long, ulong

All enums derive from System.Enum Provides methods to

determine underlying type

test if a value is supported

initialize from string constant

retrieve all values in enum

…

12/03/2014 38

Types Enums

enum Color: byte {Red = 1,Green = 2,Blue = 4,Black = 0,White = Red | Green | Blue

}

Color c = Color.Black;Console.WriteLine(c); // 0Console.WriteLine(c.Format()); // Black

12/03/2014 39

Types Arrays

Un tableau permet à un groupe d’éléments

d’un type particulier d’être stocker dans des

blocks contigus de mémoire

Les tableaux sont de types références

Dérivé de System.Array

Premier élément du tableau ‘0’

Les tableaux peuvent être multidimentionel

Chaque tableau connaît sa longueur et son

rang

Les bornes sont vérifiées

12/03/2014 40

Types Arrays

Déclaration

Allocation

Initialisation

Accès

Enumération

int[] primes;

int[] primes = new int[9];

int[] prime = new int[] {1,2,3,5,7,11,13,17,19}; int[] prime = {1,2,3,5,7,11,13,17,19};

prime2[i] = prime[i];

foreach (int i in prime) Console.WriteLine(i);

12/03/2014 41

Types Arrays

Tableau multidimensional

Régulier

int[,] matR = new int[2,3];

Il peut être initialisé de manière déclarative

int[,] matR = new int[2,3] { {1,2,3}, {4,5,6} };

Irrégulier

Un tableau de tableaux

int[][] matJ = new int[2][];

Doit être initialisé par programme

12/03/2014 42

Types Interfaces

Une interface définie un contrat

Elle contient méthodes, propriétés, indexeurs,

évènements

Chaque classe or structure implémentant une interface

doit supporter toute les parties du contrat

Les interfaces permettent le polymorphisme

Plusieurs classes et structures peuvent implémenter la

même interface

Un interface ne contient pas d’implémentation

Elle doit être implémenté par une classe ou une

structure

12/03/2014 43

Types Classes

Type référence défini par l’utilisateur Similaire aux classes C++ ou Java

Héritage simple sur les classe

Peuvent implémenter de multiples interfaces

Membres Constantes, champ (fields), méthodes, opérateurs

(constructeurs et destructeurs)

Propriétés, indexeurs, évènements

Membres par classe (static) ou par instance

Contrôle d’accès public, protected, private, internal, protected internal Le mode par défaut est private

Instantancié par l’opérateur new

12/03/2014 44

Types Structs

Similaire aux classes, mais

Type valeur défini par l’utilisateur

Hérite toujours d’objet

Ideal pour des objets ‘légers’

int, float, double, etc., sont des structures

Permet la définition de type primitifs par l’utilisateur

Complex, point, rectangle, color, rational

Héritage multiple des interfaces

Même membres que les classes

Contrôle d’accès

public, internal, private

Instancié par l’opérateur new

12/03/2014 45

Types Classes and Structs

struct SPoint { int x, y; ... }class CPoint { int x, y; ... }

SPoint sp = new SPoint(10, 20);CPoint cp = new CPoint(10, 20);

10

20sp

cp

10

20

CPoint

12/03/2014 46

Types Delegates

Un délégué (delegate) est un type référence

qui défini la signature d’une méthode

Quand il est instancié, un délégué peut faire

référence à une ou plusieurs méthodes

De manière intuitive : un pointeur sur une

fonction dans le modèle objet

Sert de base pour la gestion des évènements

12/03/2014 47

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

Code Unsafe


12/03/2014 48

Structure d’un programmeSurvol

Organisation des types

Espaces des noms

Références

Méthode principale (main)

Syntaxe

12/03/2014 49

Structure d’un programme Organisation des types

Organisation physique

Les types sont définis dans des fichiers Un fichier peut contenir

plusieurs types

Un type est défini une seule fois

Pas d’ordre dans les déclarations

Les fichiers sont compilés en modules Un module est un fichier DLL

ou EXE

Un module peut être le résultat de la compilation de plusieurs fichiers

Les modules sont regroupés en assemblage

Assembly

Module

File

Type

12/03/2014 50

Structure d’un programme Espaces de noms

Un nom de type doit être unique au sein d’un espace

de nom (Namespace)

Permet l’organisation logique des types

Il n’y a pas de relation entre les espaces de noms et

les fichiers (différence avec Java)

un assemblage peut définir plusieurs espaces de nom

Un espace de nom peut être commun à plusieurs

assemblages

La désignation d’un type par son nom qualifié

implique l’inclusion de tout l’espace de nom dans

lequel il est défini

12/03/2014 51


Il est toujours possible d’utiliser le nom qualifié

La directive using permet de s’en passer

using N1;

C1 a; // The N1. is implicitN1.C1 b; // Fully qualified name

C2 c; // Error! C2 is undefinedN1.N2.C2 d; // One of the C2 classesC1.C2 e; // The other one

namespace N1 { // N1class C1 { // N1.C1class C2 { // N1.C1.C2}

} namespace N2 { // N1.N2class C2 { // N1.N2.C2}

} }

12/03/2014 52


La directive using permet aussi de créer des synonymes

Quelques règles de bon usage :

Mettre tous ses types dans un unique espace de noms

Avoir un espace de nom par projet

Regarder comment le framework .NET est organisé

using C1 = N1.N2.C1;using N2 = N1.N2;

C1 a; // Refers to N1.N2.C1N2.C1 b; // Refers to N1.N2.C1

12/03/2014 53

Structure d’un programmeRéférences

Chaque référence identifie un assemblage

Utiliser les directives /r ou /referencedans le compilateur C#

L’espace de nom défini les noms au niveau

langage

Permet de ne pas qualifier chaque type

La référence précise quel assemblage utiliser

csc HelloWorld.cs /reference:System.WinForms.dll

12/03/2014 54

Structure d’un programmeMéthode Main

L’éxecution d’un programme démarre à la

méthode statique Main()

Une seule méthode avec une de ces

signatures par assemblage

static void Main()

static int Main()

static void Main(string[] args)

static int Main(string[] args)

12/03/2014 55

Structure d’un programmeSyntaxe

Identificateurs

Noms pour les types, les méthodes, les

champs, etc.

Un seul mot sans espace

Caractère Unicode

Le premier caractère est soit une lettre soit ‘_’

Sensible à la casse

Ne doit pas être un mot clé

Sauf si préfixé par ‘@’

12/03/2014 56

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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 blockH();; // Empty statementI();

} // End block}

12/03/2014 60

IntructionsVariables et constantes

static void Main() {const float pi = 3.14f;const int r = 123;Console.WriteLine(pi * r * r);

int a;int b = 2, c = 3;a = 1;Console.WriteLine(a + b + c);

}

Règle de portée des déclarations usuelles

Mais impossibilité de redéfinir une variable à l’intérieur d’un bloc

{int x;{int x; // Error: can’t hide variable x

}}

12/03/2014 61

Instructions Variables

Une variable doit être initialisée avant d’être lue

Explicitement ou automatiquement

Un passage en paramètre est assimilé à une lecture

L’initialisation automatique est possible pour des

champs statiques, des variables de classes ou des

éléments de tableaux

void Foo() {string s;Console.WriteLine(s); // Error

}

12/03/2014 62

Instructions goto

goto permet de tranferer le contrôle à la fin

du bloc ou hors du bloc, jamais à un bloc

interne

static void Find(int value, int[,] values, out int row, out int col) {

int i, j;for (i = 0; i < values.GetLength(0); i++)

for (j = 0; j < values.GetLength(1); j++)if (values[i, j] == value) goto found;

throw new InvalidOperationException(“Not found");

found:row = i; col = j;

}

12/03/2014 63

InstructionsExpression

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

static void Main() {int a, b = 2, c = 3;a = b + c;a++;MyClass.Foo(a,b,c);Console.WriteLine(a + b + c);a == 2; // ERROR!

}

12/03/2014 64

instructionsif

if (expression booléenne)

int Test(int a, int b) {if (a > b)return 1;

else if (a < b)return -1;

elsereturn 0;

}

12/03/2014 65

Instructions switch

int Test(string label) {int result;switch(label) {case null:goto case “runner-up”;

case “fastest”:case “winner”:result = 1; break;

case “runner-up”:result = 2; break;

default:result = 0;

}return result;

}

12/03/2014 66

Instructions while

La aussi il faut une expression booléenne

int i = 0;while (i < 5) {

...i++;

}int i = 0;do {

...i++;

}while (i < 5); while (true) {

...}

12/03/2014 67

Instructions for

for (int i=0; i < 5; i++) {...

}

for (;;) {...

}

12/03/2014 68

Instructions foreach

Permet de parcourir un tableau

Permet de parcourir une collection

Implémenté par l’interface IEnumerable

public static void Main(string[] args) {foreach (string s in args)

Console.WriteLine(s);}

foreach (Customer c incustomers.OrderBy("name")) {

if (c.Orders.Count != 0) {...

}}

12/03/2014 69

Instructions Sauts

break

Termine la boucle

continue

Termine l’itération de la boucle en cours

goto <label>

Transfert l’exécution au label

return [<expression>]

Termine la méthode

throw

Lève une exception

12/03/2014 70

Instructions Exception

Une exception est une instance de la classe System.Exception ou d’une classe dérivée

Contient des informations à propos de l’exception

Propriétés Message StackTrace InnerException

try...catch...finally try permet de lever une exception

catch permet de traiter les exceptions

Il est possible d’avoir plusieurs bloc catch pour différentes exceptions

finally contient le code qui doit toujours être executé

Il n’est pas possible de sortir d’un bloc finally par un saut (e.g. goto)

12/03/2014 71

InstructionsException

Il est possible de relever la même exception ou de la capturer

(bloc catch) pour en lever une autre

try {Console.WriteLine("try");throw new Exception(“message”);

}catch (ArgumentNullException e) {

Console.WriteLine(“caught null argument");}catch {

Console.WriteLine("catch");}finally {

Console.WriteLine("finally");}

12/03/2014 72

instructionsSynchronisation

Lock

Mutuelle exclusion

Mis en oeuvre à l’aide de la classe

System.Threading.Monitor

public class CheckingAccount {decimal balance;public void Deposit(decimal amount) {

lock (this) {balance += amount;

} }public void Withdraw(decimal amount) {

lock (this) {balance -= amount;

} } }

12/03/2014 73

Instuctions using

C# possède un ramassage des miettes (garbage collection)

Ce mécanisme ne permet pas de déterminer le moment auquel la mémoire sera libérée

Et donc de contrôler l’exécution des destructeurs

Les objects qui nécessitent d’être nettoyer lors de leur destruction doivent implémenter l’interface System.IDisposable Méthode : Dispose()

L’instruction using permet de créer une instance, de l’utiliser et de la détruire en étant certain que la méthode Dispose soit appelée à la fin de l’instruction.

12/03/2014 74

Statementsusing Statement

public class MyResource : IDisposable {public void MyResource() {// Acquire valuble resource

}public void Dispose() {// Release valuble resource

}public void DoSomething() {

...}

} using (MyResource r = new MyResource()) {r.DoSomething();

} // r.Dispose() is called

12/03/2014 75

Instructions checked et unchecked

Les instructions checked et unchecked permettent

de contrôler le débordement dans les expressions

arithmétique et les affectations

checked force le contrôle

unchecked supprime le contrôle

Peut être utilisé pour une expression ou pour un bloc

d’instruction

Le mode par défaut est unchecked

L’utilisation de la directive /checked du compilateur

permet d’utiliser le mode checked par défaut

12/03/2014 76

InstructionsEntrée / sortie

Entrée/sortie console

System.Console.WriteLine();

System.Console.ReadLine();

Appel windows

System.WinForms.MessageBox.Show();

string v1 = “some value”;MyObject v2 = new MyObject();Console.WriteLine(“First is {0}, second is {1}”,

v1, v2);

12/03/2014 77

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

Code Unsafe


12/03/2014 78

OpérateursSurvol

C# défini un ensemble d’opérateurs aillant

une sémantique précise pour les types

prédéfinis

Quelques opérateurs peuvent être

surchargés (e.g. +)

Les tableaux suivants présentent les

opérateurs

Par catégories triées par priorité

À l’intérieur d’une catégorie tous les

opérateurs ont la même priorité

12/03/2014 79

OpérateursPrécédence

Category Operators

Primary

Grouping: (x)

Member access: x.y

Method call: f(x)

Indexing: a[x]

Post-increment: x++

Post-decrement: x—

Constructor call: new

Type retrieval: typeof

Arithmetic check on: checked

Arithmetic check off: unchecked

12/03/2014 80


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


Category Operators

AdditiveAdd: +

Subtract: -

ShiftShift bits left: <<

Shift bits right: >>

Relational

Less than: <

Greater than: >

Less than or equal to: <=

Greater than or equal to: >=

Type equality/compatibility: is

Type conversion: as

12/03/2014 82


Category Operators

EqualityEquals: ==

Not equals: !=

Bitwise AND &

Bitwise XOR ^

Bitwise OR |

Logical AND &&

Logical OR ||

12/03/2014 83


Category Operators

Ternary conditional ?:

Assignment=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=

12/03/2014 84

OpérateursAssociativité

Affectation et affectation conditionelle sont

associatives à droite

x = y = z est évalué x = (y = z)

Les autres opérateurs sont associatifs à

gauche

x + y + z est évalué (x + y) + z

Si l’évaluation ne convient pas, il faut utiliser

les ‘(‘ …’)’

12/03/2014 85

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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


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


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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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 {

public void Delete() { ... }}

TextBox tb = new TextBox();IDelete iDel = tb;iDel.Delete();

Car c = new Car();iDel = c;iDel.Delete();

InterfacesExample

12/03/2014 98

interface IControl {void Paint();

}

interface IListBox: IControl {void SetItems(string[] items);

}

interface IComboBox: ITextBox, IListBox {

}

InterfacesMultiple Inheritance

Classes and structs can inherit from

multiple interfaces

Interfaces can inherit from multiple interfaces

12/03/2014 99

interface IControl {void Delete();

}

interface IListBox: IControl {void Delete();

}

interface IComboBox: ITextBox, IListBox {

void IControl.Delete();

void IListBox.Delete();

}

InterfacesExplicit Interface Members

If two interfaces have the same method

name, you can explicitly specify interface +

method name to disambiguate their

implementations

12/03/2014 100

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces

Classes et structures

Delegates

Events

Attributs


Commentaires en XML

Code Unsafe


12/03/2014 101

Classes et StructuresSimilarités

Chacune

Est un type défini par l’utilisateur

Peut implémenter plusieurs interfaces

Peut contenir

Données

Champs, constantes, événements, tableaux

Fontions

Méthodes, propriétés, indexeurs, opérateurs, constructeurs

Définition de types

Classes, structures, énumérations, interfaces, delegates

12/03/2014 102

Class Structure

Reference type Value type

Can inherit from any

non-sealed reference type

No inheritance

(inherits only from

System.ValueType)

Can have a destructor No destructor

Can have user-defined

parameterless constructor

No user-defined parameterless

constructor

Classes et StructuresDifférences

12/03/2014 103

C++ Struct C# Struct

Same as C++ class, but all

members are publicUser-defined value type

Can be allocated on the heap,

on the stack or as a member

(can be used as value or

reference)

Always allocated on the stack

or as a member

Members are always publicMembers can be public,

internal or private

Classes et StructuresC# Structures vs. C++ Structures

Différent des structures C++

12/03/2014 104

public class Car : Vehicle {

public enum Make { GM, Honda, BMW }

Make make;

string vid;

Point location;

Car(Make m, string vid; Point loc) {

this.make = m;

this.vid = vid;

this.location = loc;

}

public void Drive() { Console.WriteLine(“vroom”); }

}

Car c =new Car(Car.Make.BMW,

“JF3559QT98”, new Point(3,7));

c.Drive();

Classes et StructuresClasses

12/03/2014 105

public struct Point {int x, y;public Point(int x, int y) {

this.x = x; this.y = y;

}public int X { get { return x; }

set { x = value; } }public int Y { get { return y; }

set { y = value; } }}

Point p = new Point(2,5);p.X += 100;int px = p.X; // px = 102

Classes et StructuresStructures

12/03/2014 106

Classes et StructuresStatic vs. Instance

Par défaut, les variables sont créées par instance

Chaque instance a ses propres champs

Les méthodes sont appliquées à une instance

Les variables statiques sont associées à des types

Les méthodes statique ne peuvent pas accéder aux

données de l’instance

Pas de variable this dans les méthodes statiques

Ne pas abuser des membres statiques

Static est essentiellement utilisé pour des données

et des fonctions globales

12/03/2014 107

Classes and StructsDirectives d’accès

Les directives d’accès permettent de spécifier qui peut utiliser un type ou un membre

Les directives d’accès permettent de contrôler l’encapsulation

Les types au niveau haut (ceux associés à un namespace) peuvent être public ou internal

Les membres des classes peuvent être public, private, protected, internal ou protected internal

Les membres des structures peuvent public, private ou internal

If the access

modifier is

Then a member defined in type T and

assembly A is accessible

public to everyone

private within T only (the default)

protected to T or types derived from T

internal to types within A

protected internalto T or types derived from T

or to types within A

12/03/2014 108

Classes et StructuresClasses abstraites et classes finales

Une classe abstraite ne peut

pas être instantiée

Prévue pour être utilisée

comme une classe de base

Peuvent contenir des

fonctions membres

abstraites et non abstraites

Similaire à une interface

Ne peut être finale (‘sealed’)

Une classe finale (sealed) ne

peut être utilisé comme une

classe de base

Une classe finale ne peut être

abstraite

Une structure est implicitement

finale

Pourquoi des classes finales ?

Pour empêcher une

dérivation non souhaitée

Pour optimiser le code

L’appel des fonctions

virtuellee peut être résolu

à la compilation

12/03/2014 109

class Person {string name;public Person(string name) {

this.name = name;}public void Introduce(Person p) {

if (p != this)Console.WriteLine(“Hi, I’m “ + name);

}}

Classes et Structuresthis

Le mot clé this est une variable prédéfinie

accessible dans chaque fonction membre non

statique

Utilisé pour supprimer les ambiguïtés lors de l’accès

aux données ou aux fonctions membres

12/03/2014 110

class Shape {int x, y;public override string ToString() {

return "x=" + x + ",y=" + y;}

}class Circle : Shape {

int r;public override string ToString() {

return base.ToString() + ",r=" + r;}

}

Classes et Structuresbase

Le mot clé base est utilisé pour accéder aux

membres de classes masqués par un nom

similaire de la classe courante

12/03/2014 111

public class MyClass {public const string version = “1.0.0”;public const string s1 = “abc” + “def”;public const int i3 = 1 + 2;public const double PI_I3 = i3 * Math.PI;//ERRORpublic const double s = Math.Sin(Math.PI);...

}

Classes et StructuresConstantes

Une constante est une donnée membre qui

est évaluée à la compilation

Elle est implicitement statique

i.e. Math.PI

12/03/2014 112

Classes et StructuresChamps non modifiable (‘read-only’)

Similaire à une constante, mais initialisé à l’exécution

Une fois initiatisé, il ne plus être modifié

Différents à une constante

Initialisé à l’exécution (vs. à la compilation)

Il n’est pas nécessaire de re-compiler les client de

la classe/struct qui le défini

Il peut être statique (et partagé par les différentes

instances) ou propre à chaque instance

public class MyClass {public static readonly double d1 = Math.Sin(Math.PI);public readonly string s1;public MyClass(string s) { s1 = s; } }

12/03/2014 113

public class Button: Control {private string caption;public string Caption {

get { return caption; }set { caption = value;

Repaint(); }}

} Button b = new Button();b.Caption = "OK";String s = b.Caption;

Classes et StructuresPropriétés

Une propriété est un champ virtuel

Ressemble à un champ, mais est implémenté

par du code

Peut être read-only, write-only ou read/write

12/03/2014 114

public class ListBox: Control {private string[] items;public string this[int index] {

get { return items[index]; }set { items[index] = value;

Repaint(); }}

} ListBox listBox = new ListBox();listBox[0] = "hello";Console.WriteLine(listBox[0]);

Classes et StructuresIndexeurs

Un indexeur permet à une instance d’être un

tableau virtuel

Peut être surchargé (i.e. indexé par int et par string)

Peut être read-only, write-only ou read/write

12/03/2014 115

Classes et StructuresMéthodes

Tout code est exécuté par une méthode

Constructeurs, destructeurs et operateurs sont des types particuliers de méthodes

Propriétés et indexeurs sont implémentés par des méthodes get/set

Une méthode peut recevoir des paramètres

Passage par valeur

Ou par référence : ref (dans la signature de la méthode et dans l’appel)

Permet à une méthode de modifier la variable

La variable doit avoir une valeur avant l’appel

void RefFunction(ref int p) {p++;

} int x = 10;RefFunction(ref x);// x is now 11

12/03/2014 116

void OutFunction(out int p) {p = 22;

} int x;OutFunction(out x);// x is now 22

Classes et StructuresMéthodes

Une méthode peut recevoir des paramètres (suite)

Et avoir des paramètres retours

out (dans la signature de la méthode et dans l’appel)

La méthode doit initialiser l’argument avant de terminer

Et des paramètres résultats

12/03/2014 117

void Print(int i);void Print(string s);void Print(char c);void Print(float f);// Error: duplicate signature

int Print(float f);

Classes et StructuresSurcharge des méthodes

Il est possible de surcharger le type d’une

méthode, i.e. avoir plusieurs méthodes avec

le même nom

Chacune doit avoir une signature unique

La signature est construite uniquement sur

les arguments (la valeur de retour est

ignorée)

12/03/2014 118

int Sum(params int[] intArr) {int sum = 0;foreach (int i in intArr)sum += i;

return sum;}

int sum = Sum(13,87,34);

Classes et StructuresParamètres variables

Une méthode peut avoir un nombre variable

de paramètres

Déclaré par le mots clé : params

Doit être le dernier argument

12/03/2014 119

class Foo {public void DoSomething(int i) {...

}} Foo f = new Foo();

f.DoSomething();

Classes et StructuresMéthodes non-virtuelles

Méthodes non-virtuelles par défaut

Ne sont pas polymorphes

Elles ne peuvent pas être surchargées

Elles ne peuvent pas être abstraites

12/03/2014 120

Classes et StructuresMéthodes virtuelles

Définie dans une classe de base

Peuvent être surchargées dans une classe dérivée

Chaque classe fourni sa propre implémentation de la méthode

Peut contenir une implémentation par défaut

Si l’on ne souhaite par de méthode par défaut, utiliser une méthode abstraite

Une forme de polymorphism

Propriétés, indexeurs et évènements peut aussi être virtuel

12/03/2014 121

class Shape {public virtual void Draw() { ... }

}class Box : Shape {

public override void Draw() { ... }}class Sphere : Shape {

public override void Draw() { ... }}

void HandleShape(Shape s) {s.Draw();...

} HandleShape(new Box());HandleShape(new Sphere());HandleShape(new Shape());

Classes et StructuresMéthodes virtuelles

12/03/2014 122

Classes et StructuresMéthodes abstraites

une méthode abstraite est une méthode

virtuelle qui n’a pas d’implémentation

Doit être dans une classe abstraite

Doit être implémentée dans une classe

dérivée

12/03/2014 123

abstract class Shape {public abstract void Draw();

}class Box : Shape {

public override void Draw() { ... }}class Sphere : Shape {

public override void Draw() { ... }}

void HandleShape(Shape s) {s.Draw();...

}HandleShape(new Box());HandleShape(new Sphere());HandleShape(new Shape()); // Error!

Classes et StructuresMéthodes abstraites

12/03/2014 124

Classes et StructuresSurcharge de méthode

La surcharge doit être explicite : override ou new

Supprimer les surcharges accidentelle

Les méthodes sont non virtuelles par défaut

class Derived: Base { // version 1public virtual void Foo() {

Console.WriteLine("Derived.Foo"); }

}

class Base { // version 1}class Base { // version 2

public virtual void Foo() {Console.WriteLine("Base.Foo");

}}

class Derived: Base { // version 2anew public virtual void Foo() {

Console.WriteLine("Derived.Foo"); }

}

class Derived: Base { // version 2bpublic override void Foo() {

base.Foo();Console.WriteLine("Derived.Foo");

}}

12/03/2014 125

class B {private int h;public B() { }public B(int h) { this.h = h; }

}class D : B {

private int i;public D() : this(24) { }public D(int i) { this.i = i; }public D(int h, int i) : base(h) { this.i = i; }

}

Classes et StructuresConstructeurs

Un constructeur peut en appeler un autre

this(...) dans la même classe

base(...) pour la classe de base

Le constructeur par défaut est base()

12/03/2014 126

class Foo {~Foo() {

Console.WriteLine(“Destroyed {0}”, this); }

}

Classes et StructuresDestructeurs

Un destructeur est une méthode appelé par

lors de la destruction de l’objet (par GC)

Permet d’éliminer les objets liés

Les structures ne peuvent pas avoir de

destructeurs

12/03/2014 127

class Car {string vid;public static bool operator ==(Car x, Car y) {return x.vid == y.vid;

}}

Classes et StructuresSurcharge d’opérateur

Opérateur défini par les utilisateurs

Toujours une méthode statique

12/03/2014 128


+ - ! ~

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 precisionpublic static implicit operator double(Note x) {return ...;

}// Convert to nearest notepublic static explicit operator Note(double x) {return ...;

}}

Note n = (Note)442.578;double d = n;

Classes et StructuresOpérateur de conversion

Explicite et implicite conversion définies par

l’utilisateur

12/03/2014 132


}public class TextBox : IDelete {

public void Delete() { ... }}public class Car : IDelete {

public void Delete() { ... }}

TextBox tb = new TextBox();IDelete iDel = tb;iDel.Delete();

Car c = new Car();iDel = c;iDel.Delete();

Classes et StructuresImplementation des interfaces

Peuvent implémenter plusieurs interfaces

Doivent implémenter toutes les méthodes de l’interface héritée

12/03/2014 133


}public interface IFoo {void Delete();

}public class TextBox : IDelete, IFoo {public void IDelete.Delete() { ... }public void IFoo.Delete() { ... }

}

Classes et StructuresImplementation des interfaces

Implémentation explicite des interfaces en

cas de collision des noms

12/03/2014 134

Classes et StructuresType interne

Déclaré à l’interieur d’un autre type

Bénéfice

Un type interne peut accéder à tous les membres du type qui le défini

Un type interne est inconnu à l’extérieur du type qui le défini

12/03/2014 135

Classes et Structuresis

L’opérateur is permet de tester à l’exécution

le type d’un objet

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

}

A utiliser avec modération

Coûteux en temps…

12/03/2014 136

Classes et Structuresas

L’opérateur as converti une variable (si c’est

possible) dans le type demandé

Si ce n’est pas possible le résultat est null

static void DoSomething(object o) {Car c = o as Car;if (c != null) c.Drive();

}

Test et conversion en une seule opération

A utiliser avec modération

12/03/2014 137

Classes et Structurestypeof

L’opérateur typeof retourne le type de

l’objet désigné (appel de System.Type)

Utilise la réflexion pour obtenir

dynamiquement le type

Console.WriteLine(typeof(int).FullName);Console.WriteLine(typeof(System.Int).Name);Console.WriteLine(typeof(float).Module);Console.WriteLine(typeof(double).IsPublic);Console.WriteLine(typeof(Car).MemberType);

12/03/2014 138

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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); // Instantiatedouble x = delInst(1.0); // Invoke

}

12/03/2014 140

Delegates multicast

Un delegate peut appeler plusieurs méthodes

Les delegates multicast ne contiennent pas de fonction

le paramètre de retour est void

Chaque delegate possède sa propre liste d’appel

Les méthodes sont appelées séquentiellement, dans leur

ordre d’ajout

Opérateurs += et -=

Utilisés pour insérer supprimer une méthode à la liste du

delegate

Fonctionnent correctement avec les threads

12/03/2014 141

DelegatesMulticast Delegates

delegate void SomeEvent(int x, int y);static void Foo1(int x, int y) {Console.WriteLine("Foo1");

}static void Foo2(int x, int y) {Console.WriteLine("Foo2");

}public static void Main() {SomeEvent func = new SomeEvent(Foo1);func += new SomeEvent(Foo2);func(1,2); // Foo1

// and Foo2 are calledfunc -= new SomeEvent(Foo1);func(2,3); // Only Foo2 is called

}

12/03/2014 142

Delegateset interfaces

Il est toujours possible d’utiliser des interfaces à la place des delegates

Interfaces sont plus puissantes

Appel à de multiples méthodes

Mécanisme d’héritage

Delegates sont plus élégant pour la gestion des événements

Moins de code

Implémentation facile de plusieurs traitants d’événement dans une seule classe/structure

12/03/2014 143

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Evénements

Attributs


Commentaires en XML

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ènementsExemple coté composant (émetteur)

Définir la signature de l’événement comme un

délégué

Définir l’événement et sa logique d’emission

public delegate void EventHandler(object sender, EventArgs e);

public class Button {public event EventHandler Click;

protected void OnClick(EventArgs e) {// This is called when button is clickedif (Click != null) Click(this, e);

}}

12/03/2014 146

EvènementsExemple : coté utilisateur de l’évènement

Définir le traitement à associer à l’évènement

et l’enregistrer

public class MyForm: Form {Button okButton;

static void OkClicked(object sender,EventArgs e) {

ShowMessage("You pressed the OK button");}

public MyForm() {okButton = new Button(...);okButton.Caption = "OK";okButton.Click +=

new EventHandler(OkClicked);}

}

12/03/2014 147

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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

BrowsableShould a property or event be

displayed in the property window

Serializable Allows a class or struct to be serialized

Obsolete Compiler will complain if target is used

ProgId COM Prog ID

Transaction Transactional characteristics of a class

Quelques uns des attributs prédéfinis du framework .NET

12/03/2014 151

Attributs

[HelpUrl("http://SomeUrl/MyClass")] class Class1 {}[HelpUrl("http://SomeUrl/MyClass"),HelpUrl("http://SomeUrl/MyClass”, Tag=“ctor”)] class Class2 {}

Type type = typeof(MyClass); foreach (object attr

in type.GetCustomAttributes() ) { if ( attr is HelpUrlAttribute ) {HelpUrlAttribute ha = (HelpUrlAttribute) attr;myBrowser.Navigate( ha.Url );

}}

12/03/2014 152

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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


12/03/2014 154

Directives pour le pré processeur

Directive Description

#define, #undefDefine and undefine conditional

symbols

#if, #elif, #else,

#endifConditionally skip sections of code

#error, #warning Issue errors and warnings

#region, #end Delimit outline regions

#line Specify line number

12/03/2014 155

#define Debugpublic class Debug {[Conditional("Debug")]public static void Assert(bool cond, String s) {if (!cond) {throw new AssertionException(s);

}}void DoSomething() {...// If Debug is not defined, the next line is// not even calledAssert((x == y), “X should equal Y”);...

}}

Directives pour le pré processeurCompilation conditionnelle

12/03/2014 156

Plan


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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


Objectifs de C#

Types


Instruction

Opérateurs


Utilisation du SDK


Interfaces


Delegates

Events

Attributs


Commentaires en XML

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

Education

Transcript of Csharp2014