Caching in Swift: Redis, Memcached, and Built-in Solutions — Advanced Level

Introduction: Why Caching is the Key to Swift Application Performance

In modern Swift development, whether it's an iOS application or a server-side solution on Vapor, speed and interface responsiveness directly depend on proper data management. Caching is not just about "remembering" results; it's a whole science of how to reduce data access time, lower network and database load, and ensure smooth operation even under peak loads.

At an advanced level, Swift developers face a choice: use built-in mechanisms (NSCache, URLCache) or connect external systems like Redis and Memcached. Each of these tools has its own architecture and area of application. In this article, we will break down how to effectively integrate and combine these solutions in the Swift ecosystem.

1. Built-in Solutions: NSCache and URLCache

1.1 NSCache — Lightweight Cache for Objects

NSCache is a thread-safe dictionary built into Foundation. It is ideal for caching objects that are expensive to create or load (e.g., images, results of complex calculations). The main advantage is automatic eviction under memory pressure, which is critical for mobile applications.

import Foundation

final class ImageCache {    static let shared = ImageCache()    private let cache = NSCache<NSString, UIImage>()        private init() {        cache.countLimit = 100 // Maximum 100 objects        cache.totalCostLimit = 50 * 1024 * 1024 // 50 MB    }        func getImage(for key: String) -> UIImage? {        return cache.object(forKey: key as NSString)    }        func setImage(_ image: UIImage, for key: String, cost: Int? = nil) {        if let cost = cost {            cache.setObject(image, forKey: key as NSString, cost: cost)        } else {            cache.setObject(image, forKey: key as NSString)        }    }        func removeImage(for key: String) {        cache.removeObject(forKey: key as NSString)    }        func clearAll() {        cache.removeAllObjects()    }}

Important nuances:

• countLimit and totalCostLimit are recommendations, not hard limits. The system decides when to evict objects.
• Keys must be of type NSString, not String (Swift bridges them automatically, but explicit casting is better).
• NSCache should not be used for large data that does not fit in memory.

1.2 URLCache — Caching Network Requests

URLCache is a system cache for HTTP requests. It automatically stores server responses (considering Cache-Control headers) and returns them without network access. Configuration allows controlling memory and disk capacity.

import Foundation

// Configuring URLCache for the entire applicationlet memoryCapacity = 20 * 1024 * 1024 // 20 MBlet diskCapacity = 100 * 1024 * 1024 // 100 MBlet cache = URLCache(memoryCapacity: memoryCapacity, diskCapacity: diskCapacity, diskPath: "myCache")URLCache.shared = cache

// Example usage with URLSessionlet config = URLSessionConfiguration.defaultconfig.requestCachePolicy = .returnCacheDataElseLoad // Cache first, then networkconfig.urlCache = cache

let session = URLSession(configuration: config)let url = URL(string: "https://api.example.com/data")!let task = session.dataTask(with: url) { data, response, error in    // Data will be taken from cache if available and not stale}task.resume()

Advanced tip: Use the .reloadIgnoringLocalCacheData policy to force cache refresh, and the cachedResponse(for:) and storeCachedResponse(_:for:) methods for manual management.

2.