Transcription
1. Bienvenue: Bienvenue dans le cours sur l'
injection de dépendance sur Android
à l'aide de Health. Je m'appelle Garrett ou Hue. Je développe des
applications Android depuis 2013. Dans ce cours, vous allez
apprendre ce qu'est la dépendance, pourquoi cela peut poser problème et comment résoudre ce problème
en utilisant l'injection de dépendance. Vous apprendrez comment implémenter l' injection de
dépendance à l'aide de
la bibliothèque appelée hilt. De plus, nous allons créer une application de prévisions météorologiques
simple à l'aide de Hilt. Pour suivre ce cours, vous devez être familiarisé
avec le développement Android. Nous allons utiliser le langage de
programmation Kotlin. Également. Android Studio doit être installé
sur votre ordinateur. Si vous êtes prêt,
commençons le cours.
2. EXEMPLE: Commençons le cours par un exemple rapide
de dépendance et
d'injection de
dépendance. Ici, je vais montrer un
exemple de dépendance. Il s'agit de la classe du moteur. Il a une fonction de démarrage qui
permet au moteur de démarrer. Et nous avons la classe Car, qui crée une
instance de moteur. Et il a une fonction de démarrage qui indique que la voiture démarre
et qu'elle démarre le moteur. Nous avons également une
fonction principale où nous créons une instance de voiture et nous avons commencé. Le problème, c'est qu'ici, sur cette ligne, nous créons
des instances de moteur à l'intérieur de la voiture. Dans ce cas, le moteur
est une dépendance. La voiture
dépend des vitres du moteur. Comment pouvons-nous résoudre ce problème ? Cela peut être résolu. déplaçant, en créant une instance
en dehors de la dépendance, nous la déplaçons vers la fonction principale et nous transmettons une instance à la voiture. Nous analysons maintenant moteur d'
instance dans la voiture
à l'aide de son constructeur. C'est ce que l'on appelle
l'injection de dépendance. Exécutons ce code
et voyons le résultat. Le code fonctionne. Et c'était un
exemple rapide de ce que sont la dépendance et l'injection de
dépendance.
3. Dépendance: Dans cette vidéo, nous allons
voir ce qu'est la dépendance. La dépendance se produit
lorsqu'un composant dépend d'un autre composant. Par exemple, une classe
dépend d'une autre classe. Dans cet exemple, nous créons des instances de moteur à l'intérieur d'une voiture. La voiture dépend donc du moteur. Dans ce cas, la voiture est dépendante, l'
antigène est la dépendance. Vous pouvez dire quels peuvent être
les problèmes de dépendance. Le premier problème s'
appelle la réplication. Nous créons un
moteur d'instance dans la voiture. Il se peut donc que nous devions créer de telles
instances dans de nombreux endroits. Cela entraîne la réplication
du code. Un autre problème est
celui de la maintenabilité. Imaginez la situation dans laquelle les constructeurs de moteurs
fonctionnent en chaîne. Nous devons donc modifier
le code partout où nous créons des
instances de moteur. La gestion
du cycle de vie est un autre problème. Ici, nous créons des instances
de moteur à l'intérieur d'une voiture. Cela signifie que lorsque la
voiture est retirée, le moteur est également retiré. Ces problèmes peuvent être résolus en utilisant l'injection de
dépendance.
4. Injection de dépendance: Dans cette vidéo, nous allons voir
ce qu'est l'injection de dépendance. L'injection de dépendance crée et
injecte de la dépendance. Dans cet exemple, nous créons
une instance de moteur dans fonction
principale et transmettons la fonction de constructeur de
deux voitures. Et c'est ce qu'on appelle l'injection de
dépendance. L'injection de dépendance permet de
résoudre les problèmes de dépendance. Il s'agit de la réplication du code source en
créant une dépendance
en un seul endroit. Dans cet exemple, nous
créons des instances de moteur en fonction
principale et les
transmettons à l'objet de la voiture. Si nous devons modifier et que
son constructeur fonctionne, nous devons modifier le
code en un seul endroit. Cela améliore donc la
maintenabilité du code. L'injection de dépendances résout les problèmes liés à la gestion
du cycle de vie. Ici, nous créons des
instances d' moteur et d'un objet automobile qui passe. Ainsi, lorsque la voiture est retirée
et ne l'est pas, nous avons le
contrôle de son cycle de vie. Il existe trois types d'injection de
dépendance : injection par
constructeur, injection par champ
et injection par méthode. Comme nous l'avons vu dans l'exemple
précédent, une
dépendance est créée et transmise à la fonction du
constructeur. C'est ce que l'on appelle
l'injection de constructeur. Ce type est préféré
car nous pouvons rendre la dépendance privée pour la
rendre immuable. Un autre type est l'injection
remplie. Dans ce cas, nous injectons
une dépendance dans le champ. Ce type d'injection est utilisé lorsque le constructeur n'
est pas disponible. L'exemple est le système Android. Nous n'avons aucun
contrôle sur les composants Android tels que l'activité, les fragments, etc. Un autre type est l'injection de
méthodes. Ce type d'injection est utilisé lorsque nous n'avons pas
le contrôle du constructeur. Et nous voulons injecter plusieurs
dépendances à la fois.
5. Localisateur de service: Dans cette vidéo, nous allons
parler du localisateur de services. Il existe deux manières de
résoudre le problème de dépendance. La première méthode est l'injection de
dépendances, où les dépendances sont
injectées dans la dépendance. Afin d'implémenter l'injection de
dépendance, nous pouvons utiliser une bibliothèque guérie. Une autre façon de résoudre le problème de
dépendance est la recherche de dépendances, qui permet de
récupérer les dépendances de l'extérieur. que l'on appelle le localisateur de services, qui renvoie les dépendances
par leur nom. Permettez-moi de vous montrer un
exemple de service locator. Ici, nous avons un moteur en verre avec fonction étoile qui imprime le
moteur en train de démarrer. Nous avons ici un objet
appelé localisateur de service, qui crée une instance
de moteur et de fonction, qui renvoie les dépendances
par leur nom. exemple, il renvoie une instance de moteur lorsque le nom
est égal à deux moteurs. Si le nom n'est pas trouvé, il renvoie une exception d'
argument illégale avec une dépendance de message avec la clé suivante introuvable dans la classe de voiture. L'instance du moteur
est récupérée à partir du localisateur de services à l'aide de
la fonction de recherche avec clé du moteur. Ensuite, la fonction de démarrage imprime
que la voiture démarre et démarre le moteur. Dans la fonction principale, nous
créons une instance de moteur et l'appelons fonction de
démarrage. Le localisateur de services est un modèle
conçu qui permet d'accéder à
l'objet par son nom. Il permet de créer des objets en un seul endroit et de
les obtenir par leur nom. Il résout le problème de dépendance en créant une instance
en un seul endroit. Il n'y a donc pas d'application de code. Cela crée également une
dépendance à l'extérieur. Ainsi, un changement de dépendance n'entraîne pas un
changement de dépendance. De plus, le cycle
de vie de la dépendance
n'est pas lié au cycle
de vie de la personne à charge. localisateur de services est utilisé
par une bibliothèque appelée coin, qui n'est pas abordée dans le cadre
de ce cours.
6. Dagger et Hilt: Dagger and a dagger est une bibliothèque d'injection de
dépendances, qui facilite
la mise en œuvre de l'injection de dépendance. Cela réduit une grande partie du code
standard lors de la
mise en œuvre de l'injection de dépendances. Q est également une bibliothèque
d'injection de dépendances, construite sur Dagger
et
qui facilite
l'utilisation de Dagger. Comment ça marche. Dagger utilise un
processeur d'annotation pour analyser le code, pour identifier où injecter les dépendances et quel type de
dépendance est requis. Ensuite, Dagger génère le code source qui est compilé par le compilateur. Voici la bibliothèque
d'injection de dépendances
, construite sur Dagger. Cela permet d'écrire
moins de code en ayant des conteneurs
prédéfinis
pour les classes Android,
facilite également l'injection de
dépendances dans le modèle de vue et l'
injection du modèle de vue lui-même.
7. Code: Le code de ce cours est
disponible à l'adresse URL suivante. Si vous ouvrez cette URL, vous pouvez trouver le
référentiel de code sur GitHub, qui contient du code pour une application de
prévisions météorologiques
simple. Pour cloner
ce référentiel, cliquez sur Code, cliquez ici pour copier l'URL et
ouvrir Android Studio. Dans Android Studio, cliquez sur Fichier. Nouveau projet à partir du contrôle de
version. Ici, collez l'URL
que nous avons copiée. Et ici, vous devez définir le répertoire dans lequel vous souhaitez enregistrer le projet
et cliquer sur Cloner. Après avoir cloné le code, vous pouvez exécuter cette application
sur votre appareil ou votre émulateur.
8. Sans injection de dépendance: Dans cette vidéo, je vais montrer du code sans injection de
dépendance. Ouvrons Android Studio. Nous avons déjà cloné
du code à partir du référentiel. Et maintenant, nous sommes dans la branche principale. Nous n'avons besoin de
vérifier aucune agence d'identification. Cette branche contient du code
sans injection de dépendance. Tout d'abord, ouvrons
AndroidManifest.xml. Ici, nous pouvons voir qu'il dispose une autorisation pour la connexion
Internet, utilise du texte clair.
Le trafic est envoyé pour pouvoir utiliser la connexion HTTP. Et nous avons un écran
intitulé Activité de prévision. Dans le cadre de l'activité de prévision,
nous créons des
instances de mise à niveau à l'
aide de l'URL de base. Et nous configurons notre usine de convertisseurs
JSON afin de convertir les données
JSON en objets. En fin de compte, nous créons une
instance d'interface API. Dans la méthode OnCreate, nous définissons une
mise en page XML en
tant que vue de contenu. Ouvrons-le. Ici, nous avons une vue du recycleur pour
afficher les données prévisionnelles. Ensuite, nous appelons méthode
Jet Forecast pour
obtenir les prévisions météorologiques. Dans la méthode de prévision des avions à réaction, nous créons une co-routine
pour obtenir des prévisions météorologiques. Ensuite, nous changeons
de répartiteur principal pour
afficher les prévisions météorologiques. En bref,
nous définissons le
nom du lieu comme titre, puis nous vérifions si les données de
prévision quotidiennes sont disponibles. Si ce n'est pas nul, nous configurons le
gestionnaire de mise en page pour la vue du recycleur. Et puis nous définissons un adaptateur de
prévisions. L'adaptateur reçoit les données de
prévision et les définit selon la mise en page, qui est une prévision par élément de liste. Il en contient trois, il
faut deux ans pour afficher la date, la température
et l'état. Dans la version, des
dépendances de fichiers Gradle pour les Retrofit et bibliothèques de conversion
Retrofit et
Dishonor ont été ajoutées. Ouvrons l'interface API. Et il inclut une fonction qui renvoie
les prévisions, les réponses, les campagnes de réponse
prévisionnelle, les informations de localisation
quotidiennes actuelles pour les données de prévision. Maintenant, exécutons cette application
et voyons le résultat. Ici, vous pouvez voir l'
application qui affiche nom du
lieu dans le titre et les données de
prévisions météorologiques sous forme de liste.
9. Avec Injection de dépendance: Dans cette vidéo, nous allons voir du code avec injection de dépendance. Dans la vidéo précédente, nous
avons vu du code sans injection de
dépendance dans
lequel nous créons une instance d'API dans l'activité de
prévision. L'API est donc une dépendance et l'activité de
prévision dépend. Passons maintenant à la
branche appelée DI, qui contient du code avec injection de
dépendances. Pour utiliser la bibliothèque Here, elle doit être ajoutée
au projet. Permettez-moi de vous montrer comment il
a été ajouté. Tout d'abord,
ouvrons le fichier build gradle. Ici, nous pouvons voir que le plug-in pour la bibliothèque HIV a été ajouté. Ouvrons le
fichier Build Gradle pour le module d'application. Et un plug-in pour sa
bibliothèque a été appliqué. De plus, nous devons ajouter un processeur d'annotation
Kotlin
afin d'utiliser la bibliothèque Heal. Assurez-vous que le projet utilise Java 1.8, car la guérison l'exige. Ensuite, nous ajoutons une dépendance
pour la bibliothèque guérie. Et nous l'ajoutons pour permettre aux
références de générer du code. L'étape suivante consiste à créer une
classe appelée App, qui étend l'application et l' application Android corrigée
annotée. Cette annotation indique à heel de générer du code
d'injection de dépendance. Ouvrez AndroidManifest.xml
et déclarez l'application à l'aide de l'attribut
name. À l'intérieur du paquet IP, nous créons une classe de module
qui est annotée avec les annotations installées et les annotations
du module. Dans ce module, nous créons fonction qui est
annotée avec fournit un patient et
fournit une instance d'API qui sera injectée
dans l'activité de prévision. L'activité de prévision
est annotée avec un point d'entrée
Android pour y
injecter des dépendances. Ici, nous injectons l'
instance d' un gars avec l'annotation Inject. Nous ne le créons donc pas
dans le cadre de l'activité prévisionnelle. Maintenant, exécutons ce code
et voyons le résultat. Ici, nous pouvons voir la
même application, mais cette fois, nous avons implémenté l'injection de
dépendance.
10. Flux de travail Hilt: Dans cette vidéo, je vais vous
montrer comment fonctionne la santé. Commençons par la classe AP, qui étend l'application et utilise des annotations d'
applications Android corrigées. L'annotation indique
ici de générer un code d'injection de
dépendance
, y compris un composant singleton. Le composant Singleton est un conteneur de
dépendances au niveau de l'
application, qui injecte des dépendances. Dans la classe App Model, nous utilisons l'
annotation du module pour lui indiquer
que le module d'application
fournit des dépendances installation dans l'annotation
est utilisée pour indiquer à quel composant le module d'application
fournit des dépendances. Dans ce cas, un module fournit des dépendances pour le composant
singleton, qui est un conteneur de
dépendances au niveau de l'application. Le module d'application fournit une
dépendance car l'
instance d'API utilisant
fournit une annotation. Dans les prévisions d'activité, l'annotation du point
d'entrée Android est utilisée pour créer un composant
d'activité, qui est le fils d'un composant
singleton. Cela signifie donc que le composant
d'activité pour l'activité de
prévision a accès
aux dépendances du composant
singleton. En utilisant l'annotation Inject, nous pouvons injecter une instance d'API. Le flux de travail global
semble indiquer que ce module d'application fournit une instance d'API
à un composant singleton. composant d'activité de
l'activité de prévision a accès aux dépendances des composants uniques et injecte
des dépendances instance de
l'API
) à l'aide de l'annotation Inject.
11. ViewModel: Dans cette vidéo, je
vais montrer comment
injecter des dépendances
dans le modèle de vue. Tout d'abord,
ouvrons les modules, créons un fichier Gradle
et ajoutons une dépendance aux extensions Kotlin
pour les artefacts d'activité. Dans le modèle de vue des prévisions, nous créons des données dynamiques mutables
pour la réponse aux prévisions. Et nous créons des données en temps réel, qui seront observées
par activité prévisionnelle. Lorsque le
modèle de prévision est initialisé. Pourtant, la méthode de prévision est appelée. La méthode de prévision crée une
coroutine, qui est effacée. Lorsque ce modèle de vue est effacé. Insights est une coroutine scope. Nous obtenons les données prévisionnelles et
mettons à jour les données LiveData mutables. Dans le cadre de l'activité de
prévision, nous injectons un modèle de vue de prévision
en n'utilisant pas l'annotation Inject, mais en utilisant l'API du
fournisseur ViewModel. Sinon, nous aurions plusieurs instances
de view model. Ici, nous définissons l'observateur pour les données de prévisions
météorologiques, qui appelle la
méthode de prévision sur Update. Maintenant, exécutons cette application
et voyons le résultat. Comme vous pouvez le constater, cela fonctionne. Mais cette fois, nous obtenons
des données
sous la forme d'un modèle de vue
plutôt que d'une activité.
12. Liaisons: Dans cette vidéo, je vais montrer
comment utiliser l'annotation des liaisons. Nous créons maintenant un référentiel de données, qui sert de source de données
unique. À cette fin, nous
créons une interface appelée référentiel avec une
fonction, obtenir des prévisions. C'est une fonction de suspension qui
renvoie la réponse prévisionnelle. Nous créons une classe appelée
repository pulse, qui est l'implémentation
de l'interface du référentiel. Et il reçoit une instance d'API pour implémenter la méthode get
forecast. Dans la classe du module d'application, nous créons une fonction
qui fournit une instance d'
implémentation du référentiel
lorsque le référentiel est demandé. Ce n'est pas ici que nous
obtenons une instance d'API et que nous passons à l'implémentation du
référentiel. Dans les vidéos précédentes, nous avons
utilisé des annotations pour
indiquer la dépendance. Mais dans cette vidéo, j'aimerais montrer une autre
façon de créer une dépendance. À cette fin, nous créons
un autre module qui fournit des dépendances
pour le composant singleton. Et dans ce cas, nous utilisons l'assainissement des poubelles
pour créer une dépendance. Ici, nous créons une nouvelle
fonction qui fournit instance d'
implémentation
du référentiel lorsque le référentiel est demandé. Lorsque nous utilisons l'assainissement des liaisons, la
mise en œuvre de la fonction
est assurée par hilt. Dans l'implémentation du référentiel, nous
activons cet extrait de code pour pouvoir injecter une API lorsque
nous utilisons l'assainissement des liaisons implémentation de la fonction
est assurée par health. C'est pourquoi nous devons
utiliser l'annotation Inject dans la fonction du
constructeur pour
injecter une instance d'API. Dans la prévision que vous modélisez, nous injectons un référentiel
au lieu d'une API, qui constitue une
source de données unique. Maintenant, exécutons cette application
et voyons le résultat. Comme nous pouvons le constater, cela
fonctionne de la même manière. Mais cette fois, nous avons utilisé le
référentiel comme
source de données unique. Et nous utilisons également un système d'
assainissement intégré pour réduire la dépendance.
13. Singleton: Dans cette vidéo, je vais
montrer comment fournir même instance lorsque
la dépendance est demandée. Le module fournit des dépendances
pour le composant singleton et crée des instances à chaque
fois
qu' une dépendance
est demandée. Pour vérifier cela, nous pouvons injecter une instance d'
API et nous connecter sous forme de chaîne. Nous faisons la même chose dans la classe
Repository in Bulk. Maintenant, exécutons ce code
et voyons le résultat. Vous vous sentez ouvert à logcat, on voit bien que les instances
d'API ne sont pas les mêmes. Afin de créer un
module pour renvoyer la même instance à chaque fois nous pouvons utiliser une annotation singleton. Cette annotation indique à
Healed de
ne créer qu'une seule instance dans le conteneur de
dépendance de composants
singleton. Maintenant, exécutons ce code
et voyons le résultat. Cette fois, nous pouvons voir
que les instances sont les mêmes.
14. CONTEXTE: Dans cette vidéo, je vais montrer
comment injecter du contexte. Tout d'abord, nous devons ajouter
une dépendance pour l'intercepteur HTTP, le correcteur de
couleurs. Dans le module de l'application, nous
créons une instance d'intercepteur de chakras,
qui nécessite un contexte. Nous pouvons obtenir le contexte à l'aide de l'annotation des contextes d'
application. Ensuite, nous injectons Chocolate
Interceptor dans la fonction où nous créons une instance
d'un client HTTP OK. Ensuite, nous fournissons un client HTTP dans une fonction où nous
créons une instance de rétrofit. Maintenant, exécutons ce code
et voyons le résultat. Après l'exécution, ouvrez
le tiroir de navigation et cliquez sur notification, qui indique que l'enregistrement
est une activité GTP. Et ici, nous pouvons voir la liste des demandes qui ont été
envoyées au backend.
15. Nommé: Dans cette vidéo, je vais
montrer comment fournir des instances du même type
avec une annotation « name it ». Tout d'abord, ouvrez les modules
créés dans le fichier Gradle et ajoutez une dépendance pour l'intercepteur de
journalisation HTTP. Cette bibliothèque enregistre les
requêtes HTTP dans logcat. Ouvrez ensuite la
classe du module et ajoutez une fonction, qui fournit un autre intercepteur de
connexion. Et maintenant, nous fournissons deux
instances en même temps. Intercepteur. Lorsque nous injectons une dépendance, Heel doit savoir quelle instance
nous souhaitons injecter. À cette fin,
une annotation nommée est utilisée. Ici, nous définissons l'
annotation name it avec une clé d'
interception de connexion. Pour l'intercepteur Tucker,
nous utilisons le nom et l'annotation avec une clé d'interception
HTTP. Lorsque nous obtenons
ces instances, nous devons utiliser la même
annotation avec la même clé. Et ici, nous utilisons des intercepteurs
HTTP
pour le client HTTP. Maintenant, exécutons cette application
et voyons le résultat. Maintenant, nous pouvons voir le journal des requêtes
HTTP dans logcat.
16. Qualifier: Dans cette vidéo, je vais montrer
une autre façon de fournir des instances du même type à
l'aide d'annotations personnalisées. Dans le fichier du module d'application, nous créons deux annotations personnalisées l'aide d'une annotation qualificative. À l'aide d'
une annotation de rétention, nous faisons en sorte que cette annotation soit stockée
dans une sortie binaire. Et nous créons des annotations, intercepteur
HTTP et un intercepteur de
connexion. Nous fournissons ici des
instances d'intercepteur utilisant des annotations personnalisées
au lieu d'une annotation d'identifiant de nom. Nous remplaçons également l'annotation name
it par une annotation
personnalisée lorsque
nous obtenons ces instances. Maintenant, exécutons cette application
et voyons le résultat. Et nous pouvons voir le même résultat, journal des requêtes HTTP dans logcat.
17. Composant: Dans cette vidéo, nous allons
parler des composants. L'un des avantages
de la bibliothèque réparée est qu'elle contient des
composants prédéfinis. Les composants sont des conteneurs de
dépendance qui
injectent des dépendances. Chaque composant est lié à un cycle de vie dans une application
Android. Ici, nous pouvons voir la hiérarchie des composants et le composant principal
est un composant singleton. Il est disponible dans l'
ensemble de l'application. Il est créé lors de la création de
l'application, il est détruit lorsque
l'application est détruite. Il en va de même pour
les autres composants, par exemple composant
d'activité
est créé lorsque l'activité est créée
et détruite. Lorsque l'activité est détruite. Cela est utile lorsque nous n'avons besoin d' dépendance que pour une seule activité, et non pour l'ensemble de l'application. Selon cette hiérarchie, les dépendances du composant
singleton
sont disponibles pour le composant d'
activité,
mais les dépendances du composant d'
activité ne
sont pas disponibles pour le composant singleton ou d'autres composants tels composant
ViewModel car
il s'agit d'un composant frère. Annotation ci-dessus, chaque
composant est utilisé pour fournir une instance unique
de dépendance, par exemple annotation
singleton pour un composant
singleton ou annotation
Activity Sculpt est utilisée pour le composant activité. Créons un nouveau
module qui fournit des dépendances pour le composant
d'activité. Tout d'abord, ouvrez des modules, créez fichier Gradle et ajoutez une
dépendance à la bibliothèque Picasso. Il est utilisé pour charger l'image. Ensuite, dans le XML de prévision des éléments de la liste, nous ajoutons un nouvel ImageView pour afficher
l'icône des conditions météorologiques. Ensuite, nous créons une nouvelle interface
appelée chargeur d'images, qui a une fonction pour charger l'image depuis l'URL dans l'imagerie. Ensuite, nous créons une
implémentation d'un chargeur d' images appelé chargeur d'images
Picasso, et il implémente la fonction de
chargement d'images en utilisant la bibliothèque Picasso. Ensuite, nous créons un nouveau modèle appelé module d'activité,
qui fournit des dépendances. Pour le volet activité. Il a une fonction et il fournit, par
conséquent, un chargeur d'image, lorsque le chargeur d'images est demandé. Ici, nous utilisons l'
annotation
Activity Sculpt pour utiliser une
instance de chargeur d'images. Dans le cadre de l'activité de prévision,
nous injectons chargeur
d'images et le
transmettons à l'adaptateur de prévisions. Dans l'adaptateur de prévision, nous
obtenons ce chargeur d'images et l'utilisons pour charger l'image
depuis l'URL dans ImageView. Exécutons ce code
et voyons le résultat. Comme nous pouvons le voir maintenant, il affiche des icônes pour les
prévisions météorologiques, les conditions.
18. Merci: C'est la fin de ce
cours où vous apprendrez ce qu'est la dépendance et l'injection de
dépendance. Vous apprendrez à
configurer Healed pour implémenter l'injection de
dépendance en utilisant
différents futurs de Hailed. En prime, j'
aimerais poser des questions d'
entretien sur l'injection et la guérison de la
dépendance. Il s'agit d'un fichier PDF contenant des questions
et réponses que vous pouvez télécharger à partir de
la section des ressources de cette vidéo. Je tiens à vous remercier d'
avoir suivi ce cours. J'espère que cela vous a plu et à bientôt dans mes prochains cours.