Mise en cache en Swift (iOS/macOS) : Redis, NSCache et Core Data

Mise en cache en Swift (iOS/macOS) : de l'in-memory à Redis

Dans le développement pour iOS et macOS, la mise en cache est un outil clé pour accélérer les applications, réduire la charge sur le serveur et améliorer l'expérience utilisateur. Dans cet article, nous examinerons les principales approches de mise en cache en Swift : du simple NSCache aux solutions professionnelles basées sur Redis et SQLite. Chaque méthode a son domaine d'application, et le bon choix dépend du type de données, de leur volume et des exigences de persistance.

1. NSCache — mise en cache in-memory intégrée

NSCache est un cache léger et thread-safe intégré à Foundation. Il libère automatiquement la mémoire en cas de manque de ressources, ce qui le rend idéal pour la mise en cache d'images, de données d'API et d'autres objets temporaires.

import Foundation

class ImageCache {    private let cache = NSCache<NSString, UIImage>()        func getImage(forKey key: String) -> UIImage? {        return cache.object(forKey: key as NSString)    }        func setImage(_ image: UIImage, forKey key: String) {        cache.setObject(image, forKey: key as NSString)    }        func removeImage(forKey key: String) {        cache.removeObject(forKey: key as NSString)    }}

Avantages :

• Ne nécessite aucune configuration — fonctionne « prêt à l'emploi ».
• Gère automatiquement la mémoire (supprime les objets lors de didReceiveMemoryWarning).
• Thread-safe.

Inconvénients :

• Les données sont perdues lors du redémarrage de l'application.
• Ne convient pas aux grands volumes de données (limité par la RAM).

2. Core Data comme cache persistant

Core Data est souvent utilisé non seulement comme ORM, mais aussi comme cache pour les données structurées. C'est pratique lorsqu'il faut conserver des objets complexes avec des relations et effectuer des filtrages.

import CoreData

class CoreDataCache {    private let context: NSManagedObjectContext        init(context: NSManagedObjectContext) {        self.context = context    }        func cacheResponse(_ data: Data, forKey key: String) {        let cached = CachedResponse(context: context)        cached.key = key        cached.data = data        cached.timestamp = Date()        try? context.save()    }        func getCachedResponse(forKey key: String) -> Data? {        let fetchRequest: NSFetchRequest<CachedResponse> = CachedResponse.fetchRequest()        fetchRequest.predicate = NSPredicate(format: "key == %@", key)        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "timestamp", ascending: false)]        fetchRequest.fetchLimit = 1                guard let result = try? context.fetch(fetchRequest).first else { return nil }        return result.data    }}

Quand l'utiliser :

• Les données doivent être conservées entre les sessions.
• Un filtrage complexe est nécessaire (par exemple, recherche textuelle).
• Le volume de données est modéré (jusqu'à quelques centaines de milliers d'enregistrements).

3. Redis — mise en cache côté serveur pour Swift

Redis est un stockage in-memory haute performance fonctionnant sur le réseau. Dans le contexte de Swift (iOS/macOS), Redis est le plus souvent utilisé côté serveur (Vapor, Kitura) pour la mise en cache des sessions, des résultats de requêtes complexes et des files d'attente de tâches. Cependant, il existe des bibliothèques clientes permettant de se connecter à Redis directement depuis une application mobile (par exemple, via RediStack).

import RediStack

final class RedisCache {    private let connection: RedisConnection        init(host: String, port: Int = 6379) async throws {        self.connection = try await RedisConnection.connect(            to: .init(hostname: host, port: port)        )    }