Programmation asynchrone en Swift : guide complet pour iOS/macOS

Introduction à la programmation asynchrone en Swift

Les applications modernes pour iOS et macOS nécessitent une grande réactivité et des performances élevées. La programmation asynchrone en Swift permet d'effectuer des opérations longues (requêtes réseau, travail avec des fichiers, traitement de données) sans bloquer le thread principal (Main Thread). Depuis la version Swift 5.5, Apple a introduit le puissant modèle Swift Concurrency, basé sur les mots-clés async et await, qui simplifie considérablement l'écriture de code asynchrone par rapport aux closures traditionnelles (completion handlers) ou à DispatchQueue.

Dans ce guide, nous allons détailler tous les concepts clés : des bases de async/await aux sujets avancés comme les Actors et les Task Groups. Vous apprendrez à écrire un code asynchrone sûr, lisible et efficace pour vos projets en Swift.

Les bases de async/await en Swift

Les mots-clés async et await sont au cœur de Swift Concurrency. Ils permettent d'écrire du code asynchrone qui ressemble à du code synchrone, améliorant ainsi la lisibilité et réduisant le nombre d'erreurs.

Déclaration d'une fonction asynchrone

Pour déclarer une fonction comme asynchrone, ajoutez le mot-clé async après la liste des paramètres, mais avant le type de retour. Une telle fonction peut suspendre son exécution.

func fetchUserData(from url: URL) async throws -> Data {    let (data, response) = try await URLSession.shared.data(from: url)    // Vérification du statut HTTP    guard let httpResponse = response as? HTTPURLResponse,          httpResponse.statusCode == 200 else {        throw URLError(.badServerResponse)    }    return data}

Appel d'une fonction asynchrone avec await

Pour appeler une fonction asynchrone, on utilise le mot-clé await. Il indique que le code actuel peut se suspendre à ce point jusqu'à l'obtention du résultat.

func loadProfile() async {    let url = URL(string: "https://api.example.com/user/profile")!    do {        let data = try await fetchUserData(from: url)        // Traitement des données (par exemple, décodage JSON)        print("Données reçues : \\(data.count) octets")    } catch {        print("Erreur de chargement du profil : \\(error.localizedDescription)")    }}

Async let pour les tâches parallèles

Si vous devez exécuter plusieurs opérations asynchrones indépendantes simultanément, utilisez la construction async let. Cela permet de lancer les tâches en parallèle et d'attendre tous les résultats.

func loadDashboardData() async -> Dashboard {    async let user = fetchUserData(from: URL(string: "https://api.example.com/user")!)    async let posts = fetchUserData(from: URL(string: "https://api.example.com/posts")!)    async let notifications = fetchUserData(from: URL(string: "https://api.example.com/notifications")!)

    // Attente de tous les résultats    let (userData, postsData, notifData) = await (try user, try posts, try notifications)    return Dashboard(user: userData, posts: postsData, notifications: notifData)}

Task et Structured Concurrency

Swift Concurrency est basée sur le concept de Structured Concurrency. Cela signifie que chaque tâche asynchrone a une durée de vie claire et une relation parentale. Le bloc de construction principal est Task.

Création d'une nouvelle tâche

Task crée une nouvelle unité de travail asynchrone. Vous pouvez créer une tâche dans un contexte synchrone (par exemple, dans viewDidLoad).

class ViewController: UIViewController {    override func viewDidLoad() {        super.viewDidLoad()        // Création d'une nouvelle tâche pour effectuer un travail asynchrone        Task {            let data = try await fetchUserData(from: URL(string: "https://