SwiftUI dictionary problem when checking for nil - swift

Question

I am new to Swift and SwiftUI and this has been driving me nuts.
I have a list of items coming from a database, each associated with a User ID.
I need to display each item together with some user data (which also comes from the database). I want to save on database calls for getting user data for those users who have already appeared in my list of items.
In order to do that, I create a dictionary of user data, which I populate with each new user. If a user id is already in the dictionary, I won't be querying the database and will instead be using the cached user data in the dictionary.
So that was the idea and it seemed pretty straightforward. So I wrote the following
Main loop in the View goes through the list of items:
ForEach(xlist, id: \.self) { xentry in
Text(myModel.dictUser[xentry.actor_id]?.FirstName ?? "")
}.onAppear(perform: {myModel.cacheUser(uid: xentry.actor_id)})
in myModel, I try to cache the user:
#MainActor class myModel: ObservableObject {
#Published var dictUser: [String: STuser] = [:]
func cacheUser(uid: String) {
Task.init {
do {
if nil == dictUser[uid] {
dictUser[uid] = try await GetUserInfoFromDB(uid:uid)
}
} catch {
}
}
}
}
This should work but doesn't: the nil == dictUser[uid] in some cases (normally after a couple of entries) fails to correctly evaluate. I can see in the debugger that dictUser[uid] is clearly not a nil and contains valid data, yet the execution continues onto GetUserInfoFromDB.
Not sure what I'm doing wrong here. Any help appreciated.

Answer 1

You are trying to load data from a relatively slow, asynchronous source (a database in this case) and you want to utilise a cache to avoid the overhead of repeated database calls for the same item. A sensible approach.
With the cached items, there are three possible states:
it's already been requested and is in the cache
it's not been requested yet
it's been requested but the request is still in progress (and so the data item isn't in in the cache)
The first case is easy: if it's in the cache return it. The second case is also seemingly straightforward - you need to request the item from the database.
The last scenario is more complicated - how do you record that a request has already been made but not yet returned, and then wait for it to return it's data and send it to all those items that have requested it.
The obvious construct to represent something that can be in multiple states is an enum. For example:
enum cacheEntry {
case complete
case inProgress
}
but it's not that simple: you also want to associate each state with the data it returns from the cache.
The complete case is easy - use an associated value of the data item, in your case STUser.
The inProgress case is more complex as you want it to record the asynchronous activity that is in progress and when that activity completes return it's data item. The way to handle this is to store the asynchronous task as the associated value. So your cache entry looks like this:
enum CacheEntry {
case complete(STUser)
case inProgress(Task<STUser, Error>)
}
var cache: [String: CacheEntry] = [:]
(Note: if you're not handling the error you can replace the Error in the generic with Never.)
The question then becomes how do you use this construct?
Create a method to query the cache that can work with the async nature of the operation:
func entry(for bid: String) async throws -> STUser {
if let cacheEntry = imageCache[uid] {
switch cacheEntry {
case let .inProgress(task):
return try await task.value. //wait for the task to complete then return it's completion value
case let .downloaded(stUser):
return stUser //the item is already in the cache so return it
}
}
//There is no entry in the cache for the bid at this point
// Therefore create a task to retrieve the data asynchronously
let task = Task {
try await GetUserInfoFromDB(uid:uid)
}
//and store the task in the cache against the `uid` ready for any subsequent requests
imageCache[url] = .inProgress(task)
//process the task for the initial request
do {
//wait for the task to complete and then access its returned value
let item = try await task.value
cache[uid] = .downloaded(item) //replacing the 'inProgress' entry in the cache with the
return item // and return the retrieved value
} catch {
//if error, delete entry from the cache and handle the error
imageCache[url] = nil
throw error
}
}
The final complication now is that you have a synchronous dictionary that is being updated by an asynchronous task, with the potential for data races. To overcome this wrap the whole cache type in an actor to ensure the access to the cache is coordinated.
actor Cache {
enum CacheEntry {...}
func entry(for bid: String) async throws -> STUser {...}
}