Support formation vidéo : Programmer C#6, Préparation à la certification MCSD 70-483 (2)

Préparation de la certification MCSD 70-483: Programmer en C#
Création & définition des types
Béchir BEJAOUI
Formateur et consultant indépendant
Notes sur les méthodes
Partie II

Présentation
1
2
4
Les génériques
3
❖ Une méthode est un groupe d'instructions sensé d’être réutilisé à chaque fois
on l’appelle
❖ Les éléments d'une méthode
Modificateur d’accès: Ceci détermine la visibilité de la méthode par apport à une
autre classe.
Type de retour: Une méthode peut renvoyer une valeur, on la nomme fonction dans
ce cas, si elle retourne void on la nomme procédure
Nom de la méthode: Le nom de la méthode est un identifiant unique et il est
sensible à la casse
Liste des paramètres: Entre parenthèses, les paramètres sont utilisés pour
transmettre et recevoir respectivement des données d'une et vers la méthode
Corps de la méthode: Il contient l'ensemble des instructions nécessaires pour
effectuer l'activité requise
Les paramètres
Méthodes extensions

Présentation
1
2
4
Les génériques
3
Passage des paramètres « Valeur, référence et out »:
Les paramètres
Passage par valeur Passage par référence
Passage par out

Présentation
1
2
4
Des génériques
3
Passage de nombre indéterminé de paramètres :
Les paramètres
Avec params Sans params

Présentation
1
2
3
4
Passage de paramètres optionnels:
Les paramètres
Correct Incorrect
Les génériques

Passage de paramètres nommés:
Correct Incorrect
Présentation
1
2
3
4
Les paramètres
Les génériques

Présentation
1
2
3
4
Les méthodes extensions:
Les paramètres
Les génériques
Permet de compter le
nombre de mots dans
une chaine
Permet d’extraire un
sous groupe de mots
à partir d’une phrase
qui sont conformes à
des patterns conformes
À des expressions
régulières

Présentation
1
2
3
4
Les méthodes génériques:
Les paramètres
Les génériques
Exemple de méthode extension
Type de retour Types génériques Arguments Contraintes

Les méthodes génériques:
Incorrect
Présentation
1
2
3
4
Les paramètres
Les génériques

Ce qu’on a vu
▪ Notes sur les méthodes

Béchir BEJAOUI
Les déléguées et les expressions
Lambda

Les déléguées et les expressions Lambda
Présentation
1
2
3
Les expressions λ
4
Etudes de cas
❖ Les délégués C # sont similaires aux pointeurs vers les fonctions, en
C ou C ++
❖ Un délégué est une variable de type référence qui contient la
référence à une méthode
❖ La référence peut être modifiée lors de l'exécution
❖ Les délégués sont particulièrement utilisés dans la mise en œuvre
des événements et des méthodes de rappel « Callback »
❖ Tous les délégués sont dérivés implicitement de la classe
System.Delegate
Les déléguées

❖ Le terme «expression lambda» est dérivé du calcul «lambda» qui
est à son tour une notation mathématique appliquée pour définir les
fonctions
❖ Les expressions lambda sont principalement utilisées dans le
contexte du LINQ
❖ A ne pas confondre avec Action et Func qui sont des déléguées
prédéfinis fournit par le .Net Framework
//Définition d'une déléguée //Expression lambda
delegate (int x,int y){ return x + y; }; vs (x, y) => x + y;
Présentation
1
2
3
Comparaison
Etudes de cas

Présentation
1
2
3
Comparaison
Les types
d’arguments
Le type
de retour
Les arguments Le corps
Une comparaison d’anatomies
Etudes de cas

Présentation
1
2
3
Comparaison
Etudes de cas
❖ Utilisation des délégués pour définir des événements sans
paramètres
❖ Utilisation des délégués pour définir des événements avec
paramètres

Ce qu’on a vu
▪ Les déléguées et les expressions lambda

Béchir BEJAOUI
La programmation dynamique et la
réflexion
Partie I

La programmation dynamique et la réflexion
Présentation
1
2
❖ Les objets de réflexion sont utilisés pour obtenir des informations de
type lors de l'exécution
❖ Les classes qui donnent accès aux métadonnées d'un programme
se trouvent dans l'espace de noms System.Reflection
❖ La réflexion permet
 D'afficher les informations d'attribut lors de l'exécution
 D'examiner différents types dans un assemblage et d'instancier ces
types
 Une liaison tardive aux méthodes et aux propriétés
 Créer de nouveaux types en temps d'exécution, puis effectue certaines
tâches en utilisant ces types
Etudes de cas

Présentation
1
2
❖ Le type dynamic permet aux opérations d’être résolues au moment
de l'exécution
❖ Le type dynamic se comporte comme le type object dans la plupart
des cas
❖ Cependant, les opérations qui contiennent des expressions de type
dynamique ne sont pas résolues par le compilateur
❖ Le compilateur regroupe des informations sur l'opération et ces
informations seront ensuite utilisées pour évaluer l'opération au
moment de l'exécution
❖ Les variables de type dynamic sont compilées dans des variables de
type object.
Etudes de cas

Présentation
1
2
❖ Par conséquent, le type dynamique existe uniquement au moment
de la compilation, pas au moment de l'exécution
Etudes de cas
❖ Il est possible d’utiliser un type ExpandoObject
pour définir un objet dynamique
❖ Pour plus de personnalisation de l’objet dynamique il est possible
d’hériter de classe DynamicObject

❖ La définition et l’ utilisation des attributs
Présentation
1
2
Etudes de cas

Présentation
1
2
❖ Quelques opérations sur la réflexion
Etudes de cas

Présentation
1
❖ Quelques opérations sur les types dynamiques
2
Etudes de cas

Ce qu’on a vu
▪ La programmation dynamique et la réflexion

Béchir BEJAOUI
réflexion
Partie II

Présentation
1
2
❖ Les objets de réflexion sont utilisés pour obtenir des informations de
type lors de l'exécution
❖ Les classes qui donnent accès aux métadonnées d'un programme
se trouvent dans l'espace de noms System.Reflection
❖ La réflexion a les applications suivantes
 Il permet d'afficher les informations d'attribut lors de l'exécution
 Il permet d'examiner différents types dans un assemblage et
d'instancier ces types
 Il permet une liaison tardive aux méthodes et aux propriétés
 Il permet de créer de nouveaux types lors de l'exécution, puis effectue
certaines tâches en utilisant ces types
Etudes de cas

Présentation
1
2
❖ Le type dynamic permet aux opérations d’être résolues au moment
de l'exécution
❖ Le type dynamic se comporte comme le type object dans la plupart
des cas
❖ Cependant, les opérations qui contiennent des expressions de type
dynamique ne sont pas résolues par le compilateur
❖ Le compilateur regroupe des informations sur l'opération et ces
informations seront ensuite utilisées pour évaluer l'opération au
moment de l'exécution
Etudes de cas

Présentation
1
2
❖ Les variables de type dynamic sont compilées dans des variables de
type object.
❖ Par conséquent, le type dynamique existe uniquement au moment
de la compilation, pas au moment de l'exécutionEtudes de cas

Présentation
1
2
Etudes de cas
MethodBase MethodInfo MethodBody

Béchir BEJAOUI
réflexion
Partie III

Béchir BEJAOUI
réflexion
Partie IV

Gestion du flux de programme
Béchir BEJAOUI
Un point d’ordre

Ce qu’on a vu
▪ Un point d’ordre

Béchir BEJAOUI
Introduction des exceptions

Présentation
1
2
❖ Une exception est une anomalie qui se présente lors de l'exécution
d'un programme
❖ Les exceptions fournissent un moyen de transférer le contrôle
d'une partie d'un programme à l'autre
❖ La gestion des exceptions en C # est basée sur quatre mots
clés:
 try: Un bloc try identifie un bloc de code au niveau du quel des exceptions
particulières sont levées. Il est suivi d'un ou plusieurs blocs de capture
 Catch: Le mot-clé catch indique la capture d'une exception dans un
bloque alternatif
 Finally: Il est utilisé pour exécuter un ensemble d'instructions, qu'une
exception soit levée ou non
 throw: Une instruction qui lève une exception lorsqu'un problème apparaît
Erreurs
3
Catégories

❖ L’ erreur est un flux d’exécution non correct connu dans l'application
❖ Habituellement, dans ce cas, l'application peut intercepter ces
exceptions et / ou écrire un gestionnaire générique pour gérer toutes
les exceptions dans le système
❖ L’ exception, est généralement lancée lorsque quelques choses
inattendues se produit dans l'application
Par exemple: l'ouverture d'un fichier non existant
Par exemple: La comparaison avec un objet nulle
❖ Une erreur dans la logique du programme pouvant entraîner une
exception. Cependant, l'erreur doit être traitée non pas par la
gestion des exceptions mais en modifiant le code défectueux
Présentation
1
2
Erreurs
3
Catégories
4
Anatomie

Présentation
1
2
Erreurs
3
Catégories
Exemple de code
4
Anatomie

Exception
Application Exception System Exception
Les catégories des exceptions
Présentation
1
2
Erreurs
3
Catégories
4
Anatomie

Présentation
1
2
Erreurs
3
Catégories
4
Anatomie
Propriétés Description Acesseurs
Message Fournit des détails sur la cause de l'exception get;
StackTrace Fournit des informations sur l'endroit où l'erreur s'est
produite
get;
InnerException Fournit des informations sur la série d'exceptions qui ont pu
se produire
get;
HelpLink Fournit l'URL d'aide pour une exception particulière get;set;
Data Fournit des données arbitraires dans des paires clé-valeur get;
TargetSite Fournit le nom de la méthode où cette exception a été levée get;
Source Fournit des informations sur l’application source d’exception get;set

Présentation
1
2
Erreurs
3
Catégories
4
Anatomie
Méthodes Description
GetBaseException Retourne le type de base de l’exception levée
GetObjetData Ajoute de l’extra logique lors de la sérialisation / déserialisation
d’une exception

Ce qu’on a vu
▪ Introduction des exceptions

Béchir BEJAOUI
Les types blocs des exceptions
Partie I

Types de bloques
1
2
Exemples de blocs
throw
3
finally
4
Hiérarchie en blocs
Les types de blocs d’exceptions
5
When

Types de bloques
1
2
throw
3
finally
4
❖ Signale l’occurrence d’une exception pendant l’exécution du programme
❖ Peut également être utilisé dans un bloc catch pour lever de
nouveau une exception gérée dans un bloc catch
5
When

Types de bloques
1
2
throw
3
finally
4
❖ Il faut faire attention entre usage les deux codes suivants
5
When
Code 1 Code 2

❖ On perd les informations concernant l’origine de levée d’exception
lorsqu’on utilise throw ex au lieu de throw
Types de bloques
1
2
throw
3
finally
4
5
When
Cas d’utilisation de throw

❖ On perd les informations concernant l’origine de levée d’exception
lorsqu’on utilise throw ex au lieu de throw
Types de bloques
1
2
throw
3
finally
4
5
When
Cas d’utilisation de throw ex

❖ Le code du bloc finally est lancé que ce soit une exception est levée ou
pas
Types de bloques
1
2
throw
3
finally
4
5
When
Cas connexion à SQL Server

❖ Le bloc finally est utilisé pour libérer des ressourcesTypes de bloques
1
2
throw
3
finally
4
❖ Il n’est pas possible d’utiliser return continue ou break au niveau d’un
bloc finally
5
When

❖ Lorsqu’il s’agit de plusieurs exceptions à capturer il faut commencer
de la plus spéciale vers la plus générale
Types de bloques
1
2
throw
3
finally
4
Correct Incorrect
5
When

❖ Il est possible de filtrer les exceptions selon des critères bien
déterminés basés sur les valeurs des propriétés
Types de bloques
1
2
throw
3
finally
4
5
When

Ce qu’on a vu
▪ Les types de blocs d’exceptions

Béchir BEJAOUI
Les types blocs des exceptions
Partie II

Béchir BEJAOUI
Les exceptions les plus utilisées

Présentation
1
2
Catégories
❖ Listes des domaines
 Système
 Entrée / sortie
 Web
 Les données

Présentation
1
2
Catégories
Système
ArithmeticException DividedByZeroException OutOfMemoryException
NotImplementedException
OverflowException StackOverflowException
NullReferenceException AgregateException ArgumentException
ArgumentNullException ArgumentOutOfRangeException
IndexOutOfRangeException
InsufficientMemoryException TimeoutException

Présentation
1
2
Catégories
Les données
DbException OleDbException SqlException
SqlTypeException
DBConcurrencyException
SqlNullValueException
DataException ConstraintException
InvalidUdtException

Présentation
1
2
Catégories
Les entrées sorties
DriveNotFoundException EndOfStreamException FileLoadException
IOExceptionFileNotFoundException IsolatedStorageException
Le Web
HttpException HttpUnhandledException HttpParseException
MembershipCreateUserException
HttpRequestValidationException IsolatedStorageException
MembershipPasswordException

Ce qu’on a vu
▪ Les exceptions les plus utilisées

Béchir BEJAOUI
Partie II

Béchir BEJAOUI
Les exceptions personnalisées

Présentation
1
2
Exemple
❖ Lors de la conception de classes d'exceptions personnalisées, vous
devez dériver votre classe de System.Exception et non de
ApplicationException
❖ ApplicationException était à l'origine destiné à être utilisé pour
créer des exceptions définies par l'utilisateur, mais son utilisation
n'est plus recommandée Microsoft
❖ Vous devez dériver des exceptions personnalisées de la classe
Exception plutôt que de la classe ApplicationException

Présentation
1
2
Exemple

Ce qu’on a vu
▪ Les exceptions personnalisées

Béchir BEJAOUI
Ré cap sur les exceptions

Remarques
1
❖ Exception est une classe de base pour tout type de classe
d'exception en C #
❖ Types d'exceptions: SystemException et ApplicationException.
❖ La classe SystemException est utilisée pour les erreurs
d'exécution liées au CLR.
❖ La classe Exception inclut des propriétés importantes, par
exemple Message, StackTrace, InnerException, Data
❖ Le bloc try doit être suivi d'un catch ou d'un block finally ou des
deux.
❖ Un bloc catch multiple est autorisé avec différents filtres
d'exception. Le bloc catch général {..} doit venir en dernier.

❖ catch {..} et catch (Exception ex) {} ne peuvent pas être utilisés
ensemble
❖ Le bloc finally doit venir après le bloc try ou catch.
❖ Le bloc finally s'exécutera toujours, qu'une exception soit survenue
ou non.
❖ Le bloc finally est l'endroit approprié pour disposer des objets.
❖ Le bloc finally ne peut pas avoir de retour ou de pause car il ne
permet pas de quitter le contrôle.
❖ Les blocs try-catch imbriqués sont autorisés en C #
❖ Une exception sera interceptée dans le bloc catch interne si le filtre
approprié est trouvé, autrement sera attrapé par le bloc catch
externe
Remarques
1

Ce qu’on a vu
▪ Ré cap sur les exceptions

Béchir BEJAOUI
Une vue sur l'écosystème
Multithreading en .Net

Les points clés
1
Une vue sur l’écosystème Multithreading en .Net
❖ Les axes
 Les Threads
 La classe BackgroundWorker
 Les Tasks
 Les continuations
 Les annulations ou Cancellations
 Les verrouillages et les synchronisations

Les points clé
1
❖ Les Threads
 Les threads sont des processus légers, un thread est défini
comme le chemin d'exécution d'un programme
 Chaque thread définit un flux de contrôle unique
 L'utilisation des threads économise le gaspillage du cycle du
processeur et augmente l'efficacité d'une application
 Le thread est représenté par la classe Thread

Les points clés
1
❖ Le BackgroundWorker
 Relier la méthode à exécution de longue durée à l'événement
DoWork
 Commencer l'opération en appelant RunWorkerAsync
 Pour obtenir des informations sur le déroulement de l'opération,
il faut s’abonner à l’événement ProgressChanged
 Pour savoir quand l'opération longue est terminée, abonnez-
vous à l'événement RunWorkerCompleted
 Pour interagir avec l’ exécution il est possible à travers les
membres de DoWorkEventArgs à savoir, Argument et Result

Les points clés
1
❖ Les Tasks
 A partir de C# 4.0 une nouvelle bibliothèque s’ajoute
System.Threading.Tasks
 A la différence du Thread, l’objet Task peut retourner un objet
 Le mécanisme d’attente pour un ensemble de tâches se fait
sans besoin de l’extra code de signalisation
 L'exception de tâche enfant peut se propager à la tâche parente,
avec possibilité d’annulation de tâches avec les Cancelation Token
 La possibilité d’enchaîner les tâches pour les exécuter les
unes après les autres, avec même un établissement de
relation hiérarchique parents/ enfants
 L'implémentation asynchrone est facile dans la tâche, en
utilisant les mots-clés async et await

Les points clés
1
❖ Les annulations
 La classe CancellationTokenSource pour contrôler les
opérations annulables, et la structure CancellationToken
❖ Les continuations
 Continuer une tâche en appelant les méthodes ContinueWith,
WhenAll ou WhenAny
 Il faut comprendre la différence entre WhenAll ou WhenAny
d’une part et WaitAny WaitAll d’autre part

Les points clés
1
❖ Les verrouillages & synchronisations
 Les mécanismes et objets de verrouillage et gestion d’accès
aux sources partagées dans un contexte Multithread
 Mots clé Interlocked et lock qui permet de gérer les accès
concurrents aux ressources et aux zones critiques
 Les méthodes synchronisées décorées par
[MethodImpl(MethodImplOptions.Synchronized)]
 La classe ReaderWriterLock
 Les classes Monitor, Mutex et Semaphore

Les points clés
1
APM EAP TPL
deadlock Synchronisation TaskFactory
Threadpool atomicité Async/await
❖ Quelques concepts clé

Ce qu’on a vu
▪ Une vue sur l’écosystème Multithreading en .Net

Béchir BEJAOUI
Les Threads

Les états
1
Les threads
Démarqué
En attente
Lancé Avorté
Sleep/Interrupt
Join
Start Abort
Schéma qui représente les états de Thread
Membres
2
Start
3
Join
4
Interrupt & Abort
5
ResetAbort

Les threads
Propriétés Description
Name Obtient ou définit le nom du thread.
Priority Obtient ou définit une valeur indiquant la priorité de
planification d'un thread.
ThreadState Obtient une valeur contenant les états du thread actuel.
IsAlive Obtient une valeur indiquant l'état de l'exécution du thread
actuel.
IsBackground Obtient ou définit une valeur indiquant si le thread est un thread
d'arrière-plan ou non.
CurrentThread Obtient le thread en cours d'exécution.
CurrentPrincipal Obtient ou définit le principal actuel du thread.
CurrentCulture Obtient ou définit la culture du thread actuel.
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
IsThreadPoolThread Indique si un thread appartient au pool de threads managés ou
non.
ManagedThreadId Obtient un identificateur unique pour le thread managé
actuel.
ExecutionContext Obtient un objet ExecutionContext qui contient des
informations relatives aux divers contextes du thread actuel.
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
Start() Lance le thread.
Sleep() Suspend le thread actuel pendant la durée spécifiée.
Join() Bloque le thread appelant jusqu’à ce que le thread représenté
par cette instance s’arrête
Interrupt() Interrompt un thread dont l'état est WaitSleepJoin
Abort() Déclenche ThreadAbortException dans le thread sur lequel l'appel
a lieu
ResetAbort() Annule un Abort demandé pour le thread actuel.
VolatileRead() Lit la valeur d'un champ volatile
VolatileWrite() Écrit immédiatement une valeur dans un champ volatile
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
BeginCriticalRegion() Avertit un hôte que l'exécution est sur le point d'entrer
dans une zone de code dans laquelle les effets d'un
abandon de thread ou d'une exception non gérée
peuvent compromettre d'autres tâches
EndCriticalRegion() Avertit un hôte que l'exécution est sur le point d'entrer
dans une zone de code dans laquelle les effets d'un
abandon de thread ou d'une exception non gérée sont
limités à la tâche actuelle
MemoryBarrier() MemoryBarrier est requis uniquement sur les systèmes
multiprocesseurs avec une faible mémoire tri, équivalente
à l’emploi de lock
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
Lancement de Thread sans passage de paramètres
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
Lancement de Thread avec passage de paramètres
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
Utilisation du délégué
Utilisation de l’expression lambda
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
Cas d’utilisation de join
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Les threads
Cas d’utilisation d’interrupt
Cas d’utilisation de abort
Bloqué
Arrêté
Les états
1
Membres
2
Start
3
Join
4
Interrupt & Abort
5

Ce qu’on a vu
▪ Les threads

Béchir BEJAOUI
La classe BackgroundWorker

Membres
1
Exploitation
2
WorkerReportsProgress Obtient ou définit une valeur indiquant si
le BackgroundWorker peut signaler des mises à
jour de progression.
WorkerSupportsCancellation Obtient ou définit une valeur indiquant si
le BackgroundWorker prend en charge
l’annulation asynchrone.
IsBusy Obtient une valeur indiquant si
le BackgroundWorker une opération asynchrone
est en cours d’exécution.
CancellationPending Obtient une valeur indiquant si l’application a
demandé l’annulation d’une opération d’arrière-
plan.

RunWorkerAsync() Démarre l’exécution d’une opération d’arrière-plan.
CancelAsync() Demande l’annulation d’une opération d’arrière-plan
en attente.
ReportProgress() Déclenche l'événement ProgressChanged.
Membres
1
Exploitation
2
Evènements Description
DoWork Se produit lorsque RunWorkerAsync est appelé.
ProgressChanged Se produit lorsque ReportProgress est appelé.
RunWorkerCompleted Se produit lorsque l’opération d’arrière-plan est
terminée, a été annulée ou a levé une exception.

Membres
1
2
Exploitation
5
Les gestionnaires d’événements
1
Appel du BackgroundWorker

Membres
1
2
Exploitation
2
3
Les gestionnaires d’événements
4

Membres
1
2
Exploitation
Gestionnaires d’événementsinitialisation
Appel
Appel:
RunWorkerAsync()
CancelAsync()
Vérification :
IsBusy
Appel:
ReportProgress ()
Vérification :
CancellationPending
Vérification:
Args.ProgressPercentage
Vérification:
Args.Cancelled

Ce qu’on a vu
▪ La classe BackgroundWorker

Béchir BEJAOUI
Les Tasks

Membres
1
Les Tasks
Création
2
Status Obtient le TaskStatus de cette tâche.
IsFaulted Indique si Task s'est terminé suite à une exception non
gérée.
IsCompleted Indique si cet Task s'est terminé.
IsCanceled Indique si cette instance de Task s'est exécutée avec
succès suite à une annulation.
Id Obtient un ID pour cette instance de Task.
Factory Fournit l'accès aux méthodes de fabrique pour la
création d'instances de Task et de Task<TResult>
Exception Obtient le AggregateException qui a provoqué l'arrêt
prématuré de Task.
Async/await
3
AgregationException
4

Les Tasks
AsyncState Obtient l'objet d'état fournit quand Task a été créé, ou
null si aucun n'a été fournit.
CompletedTask Obtient une tâche qui s’est déjà terminée correctement.
CreationOptions Obtient les TaskCreationOptions utilisées pour créer cette
tâche.
CurrentId Retourne l'ID du Task en cours d'exécution.
Membres
1
Création
2
Async/await
3
AgregationException
4

Les Tasks
ConfigureAwait Configure un élément awaiter utilisé pour attendre cette
tâche
ContinueWith Crée des tâches de continuation.
Delay Crée une tâche après la durée spécifiée.
Run Crée une tâche et la place en file d'attente pour
commencer à s’executer.
RunSynchronously Exécute une tâche de manière synchrone.
Start Commence une tâche.
Wait Attend la fin de la tâche.
WaitAll Attend que toutes les tâches soient terminées.
Membres
1
Création
2
Async/await
3
AgregationException
4

Les Tasks
WaitAny Attend que l'une des tâches d'un ensemble se termine.
WhenAny Crée une tâche qui se termine lorsque toutes les tâches
spécifiées sont terminées
Membres
1
Création
2
Async/await
3
AgregationException
4

Les Tasks
Techniques de lancement des Tasks
Membres
1
Création
2
Async/await
3
AgregationException
4

Les Tasks
Membres
1
Création
2
Async/await
3
AgregationException
4
Techniques d’utilisation async await

Les Tasks
Membres
1
Création
2
Async/await
3
AgregationException
4
Exemple d’aggregatexception

Ce qu’on a vu
▪ Les Tasks

Béchir BEJAOUI
Les annulations

Les annulations
❖ Les annulations pour le cas des Tasks, il faut réviser les éléments suivants pour
l’examen MCSD
 La classe CancellationTokenSource et la structure CancellationToken
 L’exception AgregationException
❖ Les annulations pour le cas des ThreadsRubriques
1
Cas de Thread
2
Cas de Task
Cas de BackGWorker
4
3
❖ Les annulations pour le cas de la classe Backgroundworker

Les annulations
❖ Pour le cas des Threads, il faut implémenter le mécanisme suivantRubriques
1
Cas de Thread
2
Cas de Task
Cas de BackGWorker
4
3
Exemple de mécanisme d’annulation de Thread

Les annulations
❖ Pour le cas du BackgroundWorker, il suffit de passer la valeur true à e.Cancel de
DoWorkEventArgs du DoWork_Handler pour une condition donnée
Rubriques
1
Cas de Thread
2
Cas de Task
Cas de BackGWorker
4
3
Exemple de mécanisme d’annulation de tâche

Les annulations
❖ Pour le cas des Tasks , il suffit d’utiliser la classe CancellationTokenSource
et la structure CancellationToken
Rubriques
1
Cas de Thread
2
Cas de Task
Cas de BackGWorker
4
3
Exemple de mécanisme d’annulation de tâche

Ce qu’on a vu
▪ Les annulations

Béchir BEJAOUI
Les continuations

Les continuations
Rappel
1
❖ C’est l’enchainement d’exécutions des opérations d’une manière
séquentielle
❖ Avant que la bibliothèque TPL ne soit disponible, les continuations
sont effectuées en utilisant des méthodes de rappel « CallBack ».
❖ Une continuation n'est qu'une autre tâche qui ne bloque pas le
thread sur lequel elle est appelée.
❖ Les avantages des continuations sont:
 Une Invocation d’une ou plusieurs tâches en utilisant le même antécédent
 Une spécification de certaines conditions sur la base des quelles les suites doivent être
exécutées
 Une Transmission des données d'une tâche antécédente à une tâche de continuation
ContinueWith
2
WhenAny
WhenAll
4
3

Les continuations
Rappel
1
ContinueWith
2
WhenAny
WhenAll
4
3
Simple exemple qui utilise ContinueWith

Les continuations
Simple exemple qui utilise WhenAll avec Fibonaci
❖ Pour exécuter une continuation quand toutes les tâches antécédentes
sont terminées, on effectue l’appel de la méthode WhenAll
Rappel
1
ContinueWith
2
WhenAny
WhenAll
4
3

Les continuations
Simple exemple qui utilise WhenAny avec Fibonaci
❖ Pour exécuter une continuation quand n'importe quelle tâche
d'antécédent est terminée, vous appelez la méthode
statique Task.WhenAny
Rappel
1
ContinueWith
2
WhenAny
WhenAll
4
3

Les continuations
Rappel
1
Cas de Thread
2
Cas de Task
Cas de BackGWorker
4
3
❖ A ne pas confondre WhenAny et WhenAll avec WaitAny et WaitAll
❖ Deux premières sont utilisées pour la continuation et les deux
dernières sont utilisées pour la synchronisation

Ce qu’on a vu
▪ Les continuations

Béchir BEJAOUI
Les synchronisations

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3
❖ Le verrouillage avec l’objet lock
❖ L’atomicité des opérations avec interlocked
❖ La différence entre lock, Mutex, Monitor et Semaphore
❖ La synchronisation avec l’attribut MethodImpl
❖ WaitAll et WaitAny pour le cas des Tasks
❖ Le Deadlock

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3
❖ lock (this) n’est pas conseillé si l’instance est accessible
publiquement.
❖ lock (‘chaine’) tout code utilisant la même chaîne partagera le
même verrou.
❖ lock (typeof(monType)) tout code utilisant le même objet
partagera le même verrou.
❖ La bonne pratique consiste à définir un objet privé statique, pour
protéger les données communes à toutes les instances.
❖ Pour le cas des Tasks il n’est pas possible d’utiliser le mot clé await.

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3
Un simple code créant un verrouillage
sur une zone sensée critique

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3
Un simple code créant un verrouillage
sur opération atomique

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3
méthode Description
Add() Représente la somme, sous la forme d'une opération atomique
CompareExchange() Compare deux nombres
Decrement() Décrémente une variable spécifiée et stocke le résultat, sous la
forme d'une opération atomique
Increment() Incrémente une variable spécifiée et stocke le résultat sous la
forme d'une opération atomique.
Exchange() Affecte une valeur spécifiée à un handle ou un pointeur
Read(Int64) Retourne une valeur 64 bits chargée sous la forme d'une
opération atomique

Rubriques
1
lock
2
MethodImpl
Interlocked
4
3
Synchronisation de méthodes

Ce qu’on a vu
▪ Les synchronisations

Béchir BEJAOUI
Partie II

Rubriques
1
DeadLock
2
Classes de verrouillage
3
❖ La différence entre Monitor, Mutex, Semaphore, ReaderWrtierLockSlim
❖ Le Deadlock
❖ La classe TaskSchedulerLes Tasks
4

Rubriques
1
DeadLock
2
3
Exemple de méthode potentiellement génératrice d’un
DeadLock
Les Tasks
4

Rubriques
1
DeadLock
2
3
Exemple de DeadLock
Les Tasks
4
Ressource: R1 Ressource: R2
Thread: T1
Thread: T2
Assignée à T2 par
(objet verrou A )
Assignée à T1 par
(objet verrou B )
En attente de
En attente de
=

Rubriques
1
DeadLock
2
3
Exemple de DeadLock dans la vie courante
Les Tasks
4

Rubriques
1
DeadLock
2
3
Appel du code précédent qui produit
une situation de DeadLock
Les Tasks
4

Rubriques
1
DeadLock
2
3
Etude comparative des classes de verrouillage selon
Joseph Albahari
Classe Description Inter
Process
Charge d’exécution
(ns)
Monitor (lock) Garantit qu'un seul thread peut
accéder à une ressource ou à une
section de code à la fois
non 20
Mutex
oui 1000
SemaphoreSlim Garantit que pas plus d'un nombre
spécifié de threads concurrents
peuvent accéder à une ressource ou à
une section de code
non 200
Semaphore
oui 1000
ReaderWriterLockSlim Permet plusieurs lectures de coexister
avec un seule écriture
non 100Les Tasks
4
Comparaison de classes de verrouillage:

Equivalence entre lock et Monitor
Rubriques
1
DeadLock
2
3
Les Tasks
4
La classe Monitor:

La classe Monitor:
IsEntered(Object) Détermine si le thread actuel détient le verrou sur l'objet
spécifié.
Pulse(Object) Avertit un thread situé dans la file d'attente d'un changement
d'état de l'objet verrouillé.
PulseAll(Object) Avertit tous les threads en attente d'un changement d'état de
l'objet.
TryEnter() Essaie d'acquérir un verrou exclusif sur l'objet spécifié.
Wait(Object) Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce
qu'il acquière à nouveau le verrou.
Rubriques
1
DeadLock
2
3
Les Tasks
4

❖ Mutex est comme monitor, ce pendant elle peut fonctionner sur
plusieurs processus à l'échelle de l'application.
Exemple basique de verrouillage d’accès avec
Mutex
Rubriques
1
DeadLock
2
3
Les Tasks
4
La classe Mutex:

La classe Mutex:
GetAccessControl() Obtient un objet MutexSecurity qui représente la sécurité de
contrôle d'accès.
OpenExisting() Ouvre le mutex nommé spécifié, s'il existe déjà.
WaitOne() Bloque le thread actuel jusqu'à ce que le WaitHandle actuel
reçoive un signal.
TryOpenExisting() Ouvre le mutex nommé spécifié, s'il existe déjà, et retourne
une valeur indiquant si l'opération a réussi.
Rubriques
1
DeadLock
2
3
Les Tasks
4

❖ Une classe sémaphore c’ est comme les toilettes publiques qui a
une certaine capacité. Une fois elles sont pleines, plus personne ne
peut entrer
Rubriques
1
DeadLock
2
3
Les Tasks
4
Monitor & Mutex Semaphore
La classe Semaphore:

Exemple basique de verrouillage d’accès avec
Semaphore
Rubriques
1
DeadLock
2
3
Les Tasks
4

SetAccessControl() Définit la sécurité de contrôle d'accès pour un sémaphore
système nommé.
OpenExisting() Ouvre le semaphore nommé spécifié, s'il existe déjà.
WaitOne() Bloque le thread actuel jusqu'à ce que le WaitHandle actuel
reçoive un signal.
TryOpenExisting() Ouvre le semaphore nommé spécifié, s'il existe déjà, et
retourne une valeur indiquant si l'opération a réussi.
Rubriques
1
DeadLock
2
3
Les Tasks
4

Béchir BEJAOUI
Les synchronisations-Partie III

❖ La différence entre Monitor, Mutex, Semaphore, ReaderWrtierLockSlim
❖ Le Deadlock
❖ La classe TaskScheduler
Rubriques
1
WaitAny/WaitAll
2
3
TaskScheduler

Rubriques
1
WaitAny/WaitAll
2
3
TaskScheduler
❖ Les principales différences entre l’utilisation de WaitAny et
WaitAll
 WaitAny attend jusqu’à au moins la terminaison de l’une des
tâches, WaitAll attend jusqu’à la terminaison de toutes les
tâches
 WaitAny retourne un objet générique , WaitAll est void
 L’appel à la méthode WaitAll encapsule toutes les exceptions
dans une AggregateException de l’objet et les propage vers
le thread appelant.

Rubriques
1
WaitAny/WaitAll
2
3
TaskScheduler
❖ Représente un objet qui gère les tâches de bas niveau de la mise en
file d'attente de tâches sur des threads.
❖ TaskScheduler est une classe abstraite, elle ne peut pas être
instanciée.
❖ TaskScheduler fournit une méthode de gestion de partition de travail
pour l'équilibrage de charge
La classe TaskScheduler:

Le Bilan
Béchir BEJAOUI
Ce que nous avons vu ensemble

Le bilan
❖ Chapitre I
 Un petit rappel
❖ Chapitre II
 Des Notions sur des types
 Les principes de programmation orientée objets
 Des notes à propos les définitions et l’usage des méthodes
 La différence entre les délégués et les expressions Lambda
 Les notions de programmation dynamique et de réflexion

Le bilan
❖ Chapitre III
 Un point d’ordre
 Les notions relatives aux définitions et utilisations des exceptions
 Les Threads & la classe BackgroundWorker
 Les Tasks, les continuations et les annulations
 Les notions du le principe de synchronisation dans un contexte
de programmation multithreading

Le bilan
A Bientôt

Support formation vidéo : Programmer C#6, Préparation à la certification MCSD 70-483 (2)

Recommandé

Contenu connexe

Similaire à Support formation vidéo : Programmer C#6, Préparation à la certification MCSD 70-483 (2)

Similaire à Support formation vidéo : Programmer C#6, Préparation à la certification MCSD 70-483 (2) (20)

Plus de SmartnSkilled

Plus de SmartnSkilled (20)

Dernier

Dernier (16)

Support formation vidéo : Programmer C#6, Préparation à la certification MCSD 70-483 (2)