Utilisation Avancée d'AppState

August 26, 2025 · View on GitHub

Ce guide couvre des sujets avancés sur l'utilisation de AppState, y compris la création Juste-à-Temps, le préchargement des dépendances, la gestion efficace de l'état et des dépendances, et la comparaison de AppState avec l'Environnement de SwiftUI.

1. Création Juste-à-Temps

Les valeurs AppState, telles que State, Dependency, StoredState et SyncState, sont créées juste à temps. Cela signifie qu'elles ne sont instanciées que lors de leur premier accès, ce qui améliore l'efficacité et les performances de votre application.

Exemple

extension Application {
    var defaultState: State<Int> {
        state(initial: 0) // La valeur n'est pas créée tant qu'elle n'est pas consultée
    }
}

Dans cet exemple, defaultState n'est pas créé avant sa première consultation, ce qui optimise l'utilisation des ressources.

2. Préchargement des Dépendances

Dans certains cas, vous pouvez vouloir précharger certaines dépendances pour vous assurer qu'elles sont disponibles au démarrage de votre application. AppState fournit une fonction load qui précharge les dépendances.

Exemple

extension Application {
    var databaseClient: Dependency<DatabaseClient> {
        dependency(DatabaseClient())
    }
}

// Précharger lors de l'initialisation de l'application
Application.load(dependency: \.databaseClient)

Dans cet exemple, databaseClient est préchargé lors de l'initialisation de l'application, garantissant qu'il est disponible lorsque nécessaire dans vos vues.

3. Gestion de l'État et des Dépendances

3.1 État et Dépendances Partagés à Travers l'Application

Vous pouvez définir un état ou des dépendances partagés dans une partie de votre application et y accéder dans une autre partie en utilisant des identifiants uniques.

Exemple

private extension Application {
    var stateValue: State<Int> {
        state(initial: 0, id: "stateValue")
    }

    var dependencyValue: Dependency<SomeType> {
        dependency(SomeType(), id: "dependencyValue")
    }
}

Cela vous permet d'accéder au même State ou Dependency ailleurs en utilisant le même identifiant.

private extension Application {
    var theSameStateValue: State<Int> {
        state(initial: 0, id: "stateValue")
    }

    var theSameDependencyValue: Dependency<SomeType> {
        dependency(SomeType(), id: "dependencyValue")
    }
}

Bien que cette approche soit valide pour partager l'état et les dépendances à travers l'application en réutilisant le même id de chaîne, elle est généralement déconseillée. Elle repose sur la gestion manuelle de ces identifiants de chaîne, ce qui peut entraîner :

  • Des collisions d'identifiants accidentelles si le même identifiant est utilisé pour différents états/dépendances prévus.
  • Une difficulté à suivre où un état/dépendance est défini par rapport à son accès.
  • Une réduction de la clarté et de la maintenabilité du code. La valeur initial fournie dans les définitions ultérieures avec le même identifiant sera ignorée si l'état/dépendance a déjà été initialisé lors de son premier accès. Ce comportement est plus un effet secondaire du fonctionnement de la mise en cache basée sur l'identifiant dans AppState, plutôt qu'un modèle principal recommandé pour définir des données partagées. Préférez définir les états et les dépendances comme des propriétés calculées uniques dans les extensions Application (qui génèrent automatiquement des identifiants internes uniques si aucun id explicite n'est fourni à la méthode de fabrique).

3.2 Accès Restreint à l'État et aux Dépendances

Pour restreindre l'accès, utilisez un identifiant unique comme un UUID pour vous assurer que seules les bonnes parties de l'application peuvent accéder à des états ou des dépendances spécifiques.

Exemple

private extension Application {
    var restrictedState: State<Int?> {
        state(initial: nil, id: UUID().uuidString)
    }

    var restrictedDependency: Dependency<SomeType> {
        dependency(SomeType(), id: UUID().uuidString)
    }
}

3.3 Identifiants Uniques pour les États et les Dépendances

Lorsqu'aucun identifiant n'est fourni, AppState génère un identifiant par défaut basé sur l'emplacement dans le code source. Cela garantit que chaque State ou Dependency est unique et protégé contre les accès non intentionnels.

Exemple

extension Application {
    var defaultState: State<Int> {
        state(initial: 0) // AppState génère un identifiant unique
    }

    var defaultDependency: Dependency<SomeType> {
        dependency(SomeType()) // AppState génère un identifiant unique
    }
}

3.4 Accès Privé au Fichier pour l'État et les Dépendances

Pour un accès encore plus restreint au sein du même fichier Swift, utilisez le niveau d'accès fileprivate pour protéger les états et les dépendances contre tout accès externe.

Exemple

fileprivate extension Application {
    var fileprivateState: State<Int> {
        state(initial: 0)
    }

    var fileprivateDependency: Dependency<SomeType> {
        dependency(SomeType())
    }
}

3.5 Comprendre le Mécanisme de Stockage d'AppState

AppState utilise un cache unifié pour stocker State, Dependency, StoredState et SyncState. Cela garantit que ces types de données sont gérés de manière efficace dans toute votre application.

Par défaut, AppState attribue une valeur de nom "App", ce qui garantit que toutes les valeurs associées à un module sont liées à ce nom. Cela rend plus difficile l'accès à ces états et dépendances depuis d'autres modules.

4. AppState vs Environnement de SwiftUI

AppState et l'Environnement de SwiftUI offrent tous deux des moyens de gérer l'état partagé et les dépendances dans votre application, mais ils diffèrent par leur portée, leurs fonctionnalités et leurs cas d'utilisation.

4.1 Environnement de SwiftUI

L'Environnement de SwiftUI est un mécanisme intégré qui vous permet de transmettre des données partagées à travers une hiérarchie de vues. Il est idéal pour transmettre des données auxquelles de nombreuses vues ont besoin d'accéder, mais il présente des limites en ce qui concerne la gestion d'états plus complexes.

Points forts :

  • Simple à utiliser et bien intégré avec SwiftUI.
  • Idéal pour les données légères qui doivent être partagées entre plusieurs vues dans une hiérarchie.

Limites :

  • Les données ne sont disponibles que dans la hiérarchie de vues spécifique. L'accès aux mêmes données à travers différentes hiérarchies de vues n'est pas possible sans travail supplémentaire.
  • Moins de contrôle sur la sécurité des threads et la persistance par rapport à AppState.
  • Absence de mécanismes de persistance ou de synchronisation intégrés.

4.2 AppState

AppState fournit un système plus puissant et flexible pour la gestion de l'état à travers toute l'application, avec des capacités de sécurité des threads, de persistance et d'injection de dépendances.

Points forts :

  • Gestion centralisée de l'état, accessible dans toute l'application, pas seulement dans des hiérarchies de vues spécifiques.
  • Mécanismes de persistance intégrés (StoredState, FileState et SyncState).
  • Garanties de sécurité des types et des threads, assurant que l'état est accédé et modifié correctement.
  • Peut gérer une gestion d'état et de dépendances plus complexe.

Limites :

  • Nécessite plus de configuration par rapport à l'Environnement de SwiftUI.
  • Un peu moins intégré avec SwiftUI par rapport à Environment, bien qu'il fonctionne toujours bien dans les applications SwiftUI.

4.3 Quand Utiliser Chaque

  • Utilisez l'Environnement de SwiftUI lorsque vous avez des données simples qui doivent être partagées à travers une hiérarchie de vues, comme les paramètres utilisateur ou les préférences de thème.
  • Utilisez AppState lorsque vous avez besoin d'une gestion centralisée de l'état, de la persistance ou d'un état plus complexe qui doit être accessible dans toute l'application.

Conclusion

En utilisant ces techniques avancées, telles que la création juste à temps, le préchargement, la gestion de l'état et des dépendances, et en comprenant les différences entre AppState et l'Environnement de SwiftUI, vous pouvez créer des applications efficaces et économes en ressources avec AppState.

Cette traduction a été générée automatiquement et peut contenir des erreurs. Si vous êtes un locuteur natif, nous vous serions reconnaissants de contribuer avec des corrections via une Pull Request.