Prefetching collection view data

At a glance

Project structure

CollectionViewPrefetching/
├── AppDelegate.swift
├── ViewController.swift
├── CustomDataSource.swift
├── AsyncFetcher.swift
├── AsyncFetcherOperation.swift
├── Cell.swift
├── DisplayData.swift
└── Base.lproj/
    ├── Main.storyboard
    └── LaunchScreen.storyboard

Structure observations

• ViewController.swift performs screen wiring only; data-source and loading policy live outside the controller.
• CustomDataSource.swift is the boundary between index paths/cells and stable model identifiers.
• AsyncFetcher.swift owns shared fetch coordination, while AsyncFetcherOperation.swift represents one cancellable unit of work.
• Cell.swift and DisplayData.swift keep presentation state separate from request scheduling.

Overall architecture

flowchart LR
    VC["ViewController"] -->|assigns twice| CV["UICollectionView"]
    CV -->|data-source callbacks| DS["CustomDataSource"]
    CV -->|prefetch and cancel callbacks| DS
    DS --> Models["Model identifiers"]
    DS --> Fetcher["AsyncFetcher"]
    Fetcher --> Cache["NSCache"]
    Fetcher --> Queue["AsyncFetcherOperation queue"]
    Fetcher --> Handlers["completion handlers by UUID"]
    Queue --> Data["DisplayData"]
    Data -->|main queue| Guard["cell identifier guard"]
    Guard --> Cell["Cell.configure"]

Reference code

CollectionViewPrefetching/CustomDataSource.swift:40 — the adapter converts an index path to a stable identifier, checks the cache, and rejects a completion if cell reuse changed that identity.

let model = models[indexPath.row]
let identifier = model.identifier
cell.representedIdentifier = identifier

// Check if the `asyncFetcher` has already fetched data for the specified identifier.
if let fetchedData = asyncFetcher.fetchedData(for: identifier) {
    // The system has fetched and cached the data; use it to configure the cell.
    cell.configure(with: fetchedData)
} else {
    // There is no data available; clear the cell until the fetched data arrives.
    cell.configure(with: nil)

    // Ask the `asyncFetcher` to fetch data for the specified identifier.
    asyncFetcher.fetchAsync(identifier) { fetchedData in
        DispatchQueue.main.async {
            /*
             The `asyncFetcher` has fetched data for the identifier. Before
             updating the cell, check whether the collection view has recycled it to represent other data.
             */
            guard cell.representedIdentifier == identifier else { return }
            
            // Configure the cell with the fetched image.
            cell.configure(with: fetchedData)
        }
    }
}

Interpretation

Prefetching is an advisory input into the same identifier-based fetch path used by visible cells. A prefetched result can become a cache hit later; a visible-cell request can join an in-flight fetch; cancellation removes work and callbacks for identifiers no longer expected onscreen.

Ownership and state

classDiagram
    ViewController *-- CustomDataSource : private dataSource
    UICollectionView o-- CustomDataSource : dataSource and prefetchDataSource
    CustomDataSource *-- Model : 1000 identifier values
    CustomDataSource *-- AsyncFetcher : private fetch coordinator
    AsyncFetcher *-- OperationQueue : serial access and fetch queues
    AsyncFetcher *-- NSCache : fetched data
    AsyncFetcher *-- AsyncFetcherOperation : in-flight work
    AsyncFetcher *-- CompletionHandlers : callbacks keyed by UUID
    AsyncFetcherOperation *-- UUID : request identity
    AsyncFetcherOperation *-- DisplayData : produced result
    Cell o-- UUID : represented identity

Ownership evidence

CollectionViewPrefetching/AsyncFetcher.swift:14 — the fetcher privately retains the concurrency, callback, and cache state needed to coordinate all requests.

/// A serial `OperationQueue` to lock access to the `fetchQueue` and `completionHandlers` properties.
private let serialAccessQueue = OperationQueue()

/// An `OperationQueue` that contains `AsyncFetcherOperation`s for requested data.
private let fetchQueue = OperationQueue()

/// A dictionary of arrays of closures to call when an object has been fetched for an id.
private var completionHandlers = [UUID: [(DisplayData?) -> Void]]()

/// An `NSCache` used to store fetched objects.
private var cache = NSCache<NSUUID, DisplayData>()

// MARK: Initialization

init() {
    serialAccessQueue.maxConcurrentOperationCount = 1
}

The collection view stores callback references to the same adapter. The sample’s lifecycle ownership remains ViewController → CustomDataSource → AsyncFetcher.

Class and protocol design

There is no app-defined protocol. The architectural contracts are UIKit’s two collection-view protocols and Foundation’s Operation lifecycle; protocol-oriented design here means one concrete adapter fulfills two related framework roles.

Access control

Reference code

CollectionViewPrefetching/AsyncFetcherOperation.swift:10 — the operation exposes identity and read access to its output while retaining write authority.

class AsyncFetcherOperation: Operation {
    // ...
}

No declaration is public or open; private(set) is the only deliberately asymmetric setter boundary.

Logic ownership and placement

Design patterns

Naming conventions

• Role suffixes communicate framework boundaries: ViewController, CustomDataSource, AsyncFetcherOperation, and Cell.
• Asynchronous intent is explicit in fetchAsync; cache inspection and cancellation use fetchedData(for:) and cancelFetch(_:).
• representedIdentifier names view identity rather than implying the cell owns a model.
• Queue names distinguish purpose: serialAccessQueue protects bookkeeping, while fetchQueue executes slow work.
• Model.identifier, operation identifier, and cell representedIdentifier keep the same identity concept traceable across layers.

Architecture takeaways

• Feed visible-cell requests and speculative prefetches through one stable-identifier pipeline.
• Treat prefetching as an optimization: correctness still comes from cache checks and normal cell configuration.
• Coalesce duplicate requests and keep cancellation bookkeeping serialized.
• Carry model identity into reusable views and verify it before applying asynchronous results.
• Use private(set) when consumers need results but only the producer should mutate them.

Source map

• Official Apple documentation