Classes scellées (Dart 3)

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 85 sur 110.

Dart 3 a introduit les classes scellées (sealed classes), qui restreignent quelles classes peuvent les étendre ou les implémenter. Lorsque vous marquez une classe comme sealed, seules les classes du même fichier peuvent être ses sous-types directs. Cela crée un ensemble fermé de sous-types connus.

sealed class Result {}

class Success extends Result {
  final String data;
  Success(this.data);
}

class Failure extends Result {
  final String error;
  Failure(this.error);
}

La puissance des classes scellées provient de la vérification de l'exhaustivité. Lorsque vous effectuez un switch sur un type scellé, le compilateur connaît tous les sous-types possibles et s'assure que vous traitez chacun d'entre eux :

String handleResult(Result result) {
  return switch (result) {
    Success(data: var d) => 'Got: $d',
    Failure(error: var e) => 'Error: $e',
  };
  // Pas de cas par défaut nécessaire - le compilateur sait que tous les cas sont couverts !
}

void main() {
  var success = Success('Hello');
  var failure = Failure('Not found');
  
  print(handleResult(success));  // Got: Hello
  print(handleResult(failure));  // Error: Not found
}

Si vous ajoutez un nouveau sous-type à une classe scellée, le compilateur signalera chaque instruction switch qui ne le gère pas. Cela rend les classes scellées idéales pour modéliser des états, des résultats ou tout scénario où vous disposez d'un ensemble fixe de variantes. Contrairement aux classes abstraites, les classes scellées garantissent qu'aucun code externe ne peut ajouter de sous-types inattendus.

Défi

Facile

Construisons un gestionnaire de requêtes réseau en utilisant des classes scellées (sealed classes) ! Vous allez créer un système de type sécurisé qui modélise les différents états d'une réponse réseau, garantissant que chaque résultat possible est correctement géré.

Vous organiserez votre code en deux fichiers :

response.dart : Créez une hiérarchie de classes scellées qui représente tous les états possibles d'une réponse réseau :
- Une classe scellée appelée NetworkResponse qui sert de base à tous les types de réponse
- Une classe Loading qui étend NetworkResponse avec un champ String message (par exemple, "Fetching data...")
- Une classe Success qui étend NetworkResponse avec un champ String data et un champ int statusCode
- Une classe Error qui étend NetworkResponse avec un champ String errorMessage et un champ int errorCode
main.dart : Importez votre fichier de réponse et créez une fonction qui gère tous les types de réponse à l'aide d'une expression switch :
- Créez une fonction handleResponse(NetworkResponse response) qui retourne une String
- Utilisez une expression switch avec du pattern matching pour gérer chaque cas :
  - Pour Loading : retournez Status: [message]
  - Pour Success : retournez Success ([statusCode]): [data]
  - Pour Error : retournez Error ([errorCode]): [errorMessage]
- Créez trois instances de réponse et affichez le résultat de la gestion de chacune :
  - Un Loading avec le message Please wait...
  - Un Success avec les données User profile loaded et le code d'état 200
  - Un Error avec le message d'erreur Not found et le code d'erreur 404

La beauté des classes scellées est que le compilateur s'assure que vous gérez chaque type de réponse possible - aucun cas par défaut n'est nécessaire !

Sortie attendue :

Status: Please wait...
Success (200): User profile loaded
Error (404): Not found

Aide-mémoire

Les classes scellées (sealed classes) restreignent quelles classes peuvent les étendre ou les implémenter. Seules les classes situées dans le même fichier peuvent être des sous-types directs, créant ainsi un ensemble fermé de variantes connues.

sealed class Result {}

class Success extends Result {
  final String data;
  Success(this.data);
}

class Failure extends Result {
  final String error;
  Failure(this.error);
}

Les classes scellées permettent la vérification de l'exhaustivité dans les expressions switch. Le compilateur connaît tous les sous-types possibles et s'assure que vous traitez chacun d'entre eux :

String handleResult(Result result) {
  return switch (result) {
    Success(data: var d) => 'Got: $d',
    Failure(error: var e) => 'Error: $e',
  };
  // Aucun cas par défaut n'est nécessaire - tous les cas sont couverts
}

Si vous ajoutez un nouveau sous-type, le compilateur signale chaque instruction switch qui ne le gère pas. Cela rend les classes scellées idéales pour modéliser des états, des résultats ou tout ensemble fixe de variantes pour lesquels vous souhaitez des garanties au moment de la compilation que tous les cas sont traités.

Essayez vous-même

import 'response.dart';

// TODO: Créer une fonction handleResponse(NetworkResponse response)
// qui retourne une String
// Utiliser une expression switch avec pattern matching pour gérer chaque cas :
// - Pour Loading : retourner "Status: [message]"
// - Pour Success : retourner "Success ([statusCode]): [data]"
// - Pour Error : retourner "Error ([errorCode]): [errorMessage]"

void main() {
  // TODO: Créer une instance Loading avec le message "Please wait..."
  
  // TODO: Créer une instance Success avec la donnée "User profile loaded" et le code de statut 200
  
  // TODO: Créer une instance Error avec le message d'erreur "Not found" et le code d'erreur 404
  
  // TODO: Afficher le résultat du traitement de chaque réponse
}