Task/ValueTask et machine à états asynchrone (concepts)
Comprenez les résultats de Task et le principe de la machine à états asynchrone. Écrivez de petites méthodes asynchrones, composez des await et observez un TaskCompletionSource manuel.
Task/ValueTask et machine à états asynchrone (concepts) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Modèle mental
Objectif : développer une intuition de l’asynchronisme.
- Task représente un travail en cours et un résultat futur
- await met en pause, puis reprend ultérieurement
- Le compilateur crée une machine à états
- ValueTask : optimisation plus récente (présentée ici uniquement sur le plan conceptuel)
Notions de base des méthodes asynchrones
Une méthode async renvoie immédiatement un Task<T> ; elle se termine ensuite avec la valeur lorsque le travail attendu est achevé.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Program
{
// Tiny async method: returns Task<int>
static async Task<int> GetAnswerAsync()
{
// Offload simple work to a thread-pool task (demo only)
int value = await Task.Run(() =>
{
Thread.Sleep(200); // simulate work
return 42;
});
return value; // completes Task<int>
}
public static void Main(string[] args)
{
// In C# 6, Main cannot be async; block just for demo (console apps are safe here)
int result = GetAnswerAsync().Result;
Console.WriteLine("Answer = " + result);
}
}
Composer des attentes
await permet d’écrire des étapes asynchrones séquentielles dans un style clair, de haut en bas.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Program
{
static async Task<int> Step1Async()
{
// pretend I/O
await Task.Delay(100);
return 10;
}
static async Task<int> Step2Async(int x)
{
await Task.Delay(100);
return x * 3; // simple transform
}
static async Task<int> PipelineAsync()
{
int a = await Step1Async(); // await first
int b = await Step2Async(a); // then await second
return a + b; // total 10 + 30 = 40
}
public static void Main(string[] args)
{
int total = PipelineAsync().Result; // block in demo
Console.WriteLine("Total = " + total);
}
}
Principe de la machine à états
Concept : le compilateur transforme une méthode asynchrone en machine à états.
- Les variables locales sont stockées dans des champs
- Chaque await produit un nouvel état
- Lorsque la Task attendue se termine, une continuation reprend la méthode
- Les exceptions sont capturées et enregistrées dans la Task
Démonstration de TaskCompletionSource
TaskCompletionSource vous permet de créer une Task et de signaler sa fin ultérieurement ; await la consomme comme n’importe quelle autre Task.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Program
{
// Emulate an async source that completes later
static Task<string> MakeTaskManually()
{
var tcs = new TaskCompletionSource<string>();
// Complete on a worker after a short delay
ThreadPool.QueueUserWorkItem(_ =>
{
Thread.Sleep(150);
tcs.SetResult("done");
});
return tcs.Task;
}
static async Task<string> UseAsyncSource()
{
string s = await MakeTaskManually(); // await a Task you created
return s.ToUpperInvariant();
}
public static void Main(string[] args)
{
Console.WriteLine(UseAsyncSource().Result);
}
}
Concept de ValueTask
ValueTask (concept) : type de retour plus récent qui réduit les allocations lorsque les résultats sont fréquemment disponibles de manière synchrone.
- Utile lorsque les résultats sont déjà disponibles la plupart du temps
- Possède des règles permettant d’éviter les allocations supplémentaires
- Non disponible en C# 6 : utilisez Task ici ; les principes restent valables
Machine à états asynchrone
Récapitulatif
Récapitulatif : Task modélise le travail ; await met en pause puis reprend l’exécution ; le compilateur construit une machine à états. ValueTask est un concept d’optimisation (utilisez Task en C# 6).
Questions Fréquemment Posées
La leçon « Task/ValueTask et machine à états asynchrone (concepts) » est-elle gratuite ?
Oui — le texte complet de « Task/ValueTask et machine à états asynchrone (concepts) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Task/ValueTask et machine à états asynchrone (concepts) » ?
Comprenez les résultats de Task et le principe de la machine à états asynchrone. Écrivez de petites méthodes asynchrones, composez des await et observez un TaskCompletionSource manuel. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « Task/ValueTask et machine à états asynchrone (concepts) » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Task/ValueTask et machine à états asynchrone (concepts)
- Pièges de l’asynchronisme : sync-over-async et interblocages
- ConfigureAwait et propagation des exceptions