Programmation asynchrone en Kotlin

Name: Programmation asynchrone en Kotlin
Author: David Powers

Terminez votre parcours de codage Kotlin avec ce cours avancé

Preview the first lesson free — get full access to all 4 lessons.

Cours : à la demande

Bonjour et bienvenue. Dans cette leçon, vous découvrirez les fondements de la programmation asynchrone. Vous apprendrez ce que signifie réellement le terme et pourquoi c'est si important dans le cadre de l'interface utilisateur d'Androïd. Donc, la raison pour laquelle nous avons la programmation asynchrone c'est parce que certaines fonctions en programmation long à exécuter, comme l'appel, comme le réseautage, comme une requête HTTP, le chargement de fichiers multimédias, appeler un serveur, appeler une API, ou appeler un calcul lourd. Toutes ces fonctions prennent du temps à faire. Les programmeurs ont donc proposé le concept de la programmation asynchrone, par lequel vous n'avez pas à exécuter toutes vos fonctions séquentiellement ou de façon synchrone. Au lieu de cela, vous pouvez l'exécuter de manière asynchrone pour faire du travail en parallèle ou exécuter des fonctions et de la simultanéité. Donc, toutes ces situations où vous avez un long appel à une fonction, il est essentiel que vous souhaitiez éviter toutes ces mauvaises performances qui peuvent causer votre application être insensible ou lent, ou même de s'écraser. Nous avons donc cette méthode appelée programmation asynchrone où nous pouvons envoyer votre logique dans une branche alternative ou un fil alternatif pendant que le fil principal continue avec la lourde charge. Vous pouvez donc créer des fonctions asynchrones faire deux choses différentes ou plusieurs choses. Et s'il fait une chose avec succès, alors vous pouvez rester sur le fil principal. Mais si quelque chose ne va pas, vous pouvez passer à un autre fil. Donc, vous faites simplement de la programmation asynchrone chaque fois que vous appelez une fonction qui a été configurée de manière asynchrone, de sorte que lorsque le programme commence un fil, il pourrait juste rester là pendant un certain temps et attend que vous retourniez une valeur. Comme je vais cliquer dessus et il attend cette valeur ici être retourné, mais cette valeur peut ne pas être renvoyée immédiatement. Mais à un moment donné dans le futur, il sera retourné, et cela sera géré de manière asynchrone. Et si vous effectuez une requête réseau ou vous interrogez une base de données, il y aura presque certainement un retard dans votre fonctionnalité. Et quand il y a du retard et que tu essaies quelque chose de façon synchrone, alors tu vas avoir de gros problèmes. Il est donc très important d'écrire votre code d'une manière qui anticipe le retard ou le blocage, et vous le coupez de manière à ce que votre logique fonctionne de manière bloquante pour bloquer le délai et choisit un itinéraire différent ou un fil différent. Donc, si le thread principal attend de recevoir une réponse à partir d'une requête réseau, en programmation asynchrone, il serait bloqué jusqu'à ce qu'il soit capable de s'en occuper de ces responsabilités. Et pendant ce temps, le programme peut continuer à faire autre chose selon qu'il y a succès ou échec. Et il le fait de manière asynchrone. Il existe donc plusieurs façons de gérer la programmation asynchrone. L'une des méthodes les plus anciennes consiste à utiliser un modèle de rappel, par lequel la fonction renvoie nos appels vers une certaine valeur. Une autre façon de faire de Kotlin est d'utiliser des coroutines, qui a été créé par Kotlin pour gérer la programmation asynchrone de manière très efficace, appelées coroutines. Et nous les utilisons pour que le flux de votre programme Kotlin peut se déplacer de manière efficace dans les trois entités d'un déroulement de programme. Et ce flux de programme a toujours une chose qui produira des données. Et puis il y a quelque chose qui va modifier les données. Et puis il y a quelque chose qui utilisera les données, et cela s'appelle normalement un consommateur de données. Donc je vais produire des données en faisant ce clic, et puis il y a une modification. Et puis nous consommons les données qui sont ici. Et nous le faisons grâce à l'interaction de l'utilisateur. Donc on fait de la programmation asynchrone, et surtout, à Kotlin, nous faisons des coroutines pour deux raisons. L'un est, à un moment donné, nous allons avoir une tâche de longue haleine ça fait des calculs lourds et ça bloque le thread principal. Nous devons donc le contourner de manière asynchrone. Et puis l'autre raison est pour des raisons de sécurité où nous devons suspendre une fonction jusqu'à ce que nous puissions réussir. Maintenant, chaque programme Kotlin commence avec un fil conducteur ou une activité principale. Et il restera sur ce fil principal à travers toutes vos tâches d'interface utilisateur jusqu'à ce que vous codiez autre chose. Il faut donc coordonner ta tâche avec l'interaction de l'utilisateur. Et vous pourriez le faire grâce à la programmation asynchrone et coordonner à travers des coroutines. Donc, tout cela va à l'expérience utilisateur et l'amélioration de l'expérience utilisateur, et améliorer l'interaction avec l'utilisateur, car la programmation asynchrone permet à l'utilisateur faire des choses dans l'application comme cliquer sur un bouton pendant qu'un autre processus s'exécute en arrière-plan et produire un autre type de résultat. Et tout cela améliore l'expérience utilisateur. Voilà qui conclut notre leçon sur les fondations de la programmation asynchrone. Merci d'avoir regardé. Restez à l'écoute pour la prochaine leçon. Alors allons-y.

Avancé Fournisseur : David Powers 4 leçons · 26m en Arabe, Allemand, Anglais, Espagnol, Français, Portugais, Chinese

Description du cours

Dans ce chapitre, vous découvrirez les bases du codage asynchrone. Vous apprendrez à créer du code asynchrone et à utiliser ce code pour améliorer votre vitesse de traitement. Vous apprendrez la différence entre la programmation synchrone et asynchrone. Enfin, vous allez créer votre toute première routine asynchrone dans Kotlin.

Ce que vous allez apprendre

Créer et utiliser du code asynchrone pour améliorer la vitesse de traitement
Explorer les fondements de la programmation asynchrone
Distinguer la programmation synchrone de la programmation asynchrone
Créer des modèles de rappel (callback patterns) dans le code asynchrone
Appliquer la méthodologie async await de Kotlin
Créer votre première routine asynchrone en Kotlin

Points clés à retenir

Le code asynchrone peut être utilisé pour améliorer la vitesse de traitement.
La programmation synchrone et asynchrone diffèrent dans la manière dont le code est exécuté.
Les modèles de rappel (callback patterns) sont un moyen de structurer le code asynchrone.
Kotlin fournit les méthodes async await pour l'écriture de routines asynchrones.
Le chapitre guide les apprenants dans la création de leur première routine asynchrone en Kotlin.

Foire aux questions

Que couvre ce chapitre ?

Il couvre les bases du codage asynchrone, y compris comment créer du code asynchrone, la différence entre la programmation synchrone et asynchrone, les modèles de rappel (callback patterns), et la méthodologie async await de Kotlin.

Quelles compétences vais-je acquérir grâce à ce cours ?

Le cours couvre des compétences comprenant les concepts de programmation asynchrone, les modèles de rappel, la méthodologie async await de Kotlin, et Kotlin.

Vais-je écrire du code asynchrone moi-même ?

Oui. À la fin du chapitre, vous créerez votre toute première routine asynchrone en Kotlin.

Quelle est la différence entre la programmation synchrone et asynchrone dans ce cours ?

Le cours comprend une leçon sur la programmation synchrone par rapport à la programmation asynchrone et vous apprend à comprendre la différence entre les deux approches.

Quelles leçons sont incluses ?

Les leçons sont : Fondements de la Programmation Asynchrone, Synchrone vs Asynchrone, Modèles de Rappel (Callback Patterns), et Méthodologie Async Await de Kotlin.