Building high-performance lists and collection views

At a glance

Project structure

CollectionViewSample/
├── AppDelegate.swift
├── SceneDelegate.swift
├── DestinationPost.swift
├── PostGridViewController.swift
├── Stores/
│   ├── SampleData.swift
│   ├── ModelStore.swift
│   └── AssetStore.swift
├── Utilities/
│   ├── MemoryLimitedCache.swift
│   ├── FileBasedCache.swift
│   ├── PlaceholderStore.swift
│   ├── UnfairLock.swift
│   └── URLSession+DownloadTaskPublisher.swift
└── Views/
    ├── DestinationPostCell.swift
    ├── DestinationPostPropertiesView.swift
    └── SectionBackgroundView.swift

Structure observations

• Stores own lookup and asset preparation; view files own drawing/layout and cell request lifetime.
• Utility caches separate memory pressure, disk I/O, downsampling, and locking concerns.
• SceneDelegate is the composition root; AppDelegate only supplies scene lifecycle configuration.

Overall architecture

flowchart LR
    Scene["SceneDelegate"] -->|"inject stores"| Grid["PostGridViewController"]
    Grid --> Sections["AnyModelStore<Section>"]
    Grid --> Posts["AnyModelStore<DestinationPost>"]
    Grid --> Assets["AssetStore"]
    Grid --> Diffable["Diffable data source"]
    Diffable --> Cell["DestinationPostCell"]
    Grid -->|"prefetch / cancel"| Assets
    Cell -->|"retains Cancellable"| Assets
    Assets --> Memory["MemoryLimitedCache"]
    Assets --> Placeholder["PlaceholderStore"]
    Assets --> Disk["FileBasedCache"]
    Assets --> Prepare["download + preparingForDisplay"]
    Prepare --> Disk
    Prepare --> Memory

Reference code

CollectionViewSample/PostGridViewController.swift:53 — cell registration joins model lookup, placeholder delivery, asynchronous loading, cancellation-token transfer, and item reconfiguration.

let cellRegistration =
    UICollectionView.CellRegistration<DestinationPostCell, DestinationPost.ID> {
        [weak self] cell, indexPath, postID in
        guard let self = self else { return }

        let post = self.postsStore.fetchByID(postID)
        let asset = self.assetsStore.fetchByID(post.assetID)
        var token = self.prefetchingIndexPathOperations
            .removeValue(forKey: indexPath) ?? cell.assetToken

        if asset.isPlaceholder && token == nil {
            token = self.assetsStore.loadAssetByID(post.assetID) {
                [weak self] in self?.setPostNeedsUpdate(postID)
            }
        }
        cell.assetToken = token
        cell.configureFor(post, using: asset)
    }

Interpretation

The controller owns UI scheduling, not image-processing details. It asks the asset store for the best immediately available representation, carries a cancellable from prefetch to the visible cell, and reconfigures only the affected identifier when the prepared image arrives.

Ownership and state

classDiagram
    PostGridViewController o-- AnyModelStore : injected section and post stores
    PostGridViewController o-- AssetStore : injected
    PostGridViewController *-- UICollectionViewDiffableDataSource : UI snapshot owner
    PostGridViewController *-- AnyCancellable : prefetch operations by IndexPath
    DestinationPostCell *-- Cancellable : current asset assertion/request
    AssetStore *-- MemoryLimitedCache : prepared images
    AssetStore *-- FileBasedCache : local originals
    AssetStore *-- PlaceholderStore : downsampled placeholders
    AssetStore *-- SharedPublisher : in-flight request per asset ID
    MemoryLimitedCache *-- AssetDictionary : cached assets
    MemoryLimitedCache *-- AssertionCounts : protected asset IDs

Ownership evidence

CollectionViewSample/Stores/AssetStore.swift:100 — one shared publisher is retained per asset ID and removed when the pipeline completes.

private var requestsCache:
    [Asset.ID: Publishers.Share<AnyPublisher<Asset, Never>>] = [:]

func prepareAssetIfNeeded(
    id: Asset.ID
) -> Publishers.Share<AnyPublisher<Asset, Never>> {
    if let request = requestsCache[id] {
        return request
    }

    let publisher = prepareAsset(id: id)
        .subscribe(on: Self.networkingQueue)
        .receive(on: DispatchQueue.main)
        .handleEvents(receiveCompletion: { [weak self] _ in
            self?.requestsCache.removeValue(forKey: id)
        })
        .assertNoFailure("Downloading Asset (id: \(id)")
        .eraseToAnyPublisher()
        .share()
    requestsCache[id] = publisher
    return publisher
}

Class and protocol design

The local protocols capture two narrow lookup capabilities. Despite its name, AnyModelStore is not a general closure-based type eraser; it is a concrete generic dictionary store that satisfies ModelStore.

Access control

Reference code

CollectionViewSample/Utilities/MemoryLimitedCache.swift:26 — externally readable memory accounting surrounds private, lock-guarded residency state.

class MemoryLimitedCache: Cache {
    let memoryLimit: Measurement<UnitInformationStorage>
    private(set) var currentMemoryUsage =
        Measurement<UnitInformationStorage>.zero

    private let accessLock = UnfairLock()
    private var assets: [Asset.ID: Asset] = [:]
    private var protectedAssetIDs: [Asset.ID: Int] = [:]
    private var cancellation = [AnyCancellable]()
}

Logic ownership and placement

Design patterns

Naming conventions

• Storage roles use Store or Cache: AssetStore, AnyModelStore, PlaceholderStore, and MemoryLimitedCache.
• Pipeline methods describe phases: fetchByID, loadAssetByID, prepareAssetIfNeeded, and makeDownloadRequest.
• DestinationPostCell and DestinationPostPropertiesView name the domain element plus UI role.
• Boolean/state names reveal policy: isPlaceholder, currentMemoryUsage, protectedAssetIDs, and prefetchingIndexPathOperations.

Architecture takeaways

• Inject stores at the scene/controller boundary and keep cache mechanics out of cells and view controllers.
• Tie asynchronous work to UI lifetime with cancellables that move from prefetch ownership to cell ownership.
• Deduplicate work by stable asset ID and reconfigure diffable items by identity.
• Separate prepared-memory, original-disk, and placeholder-disk policies.
• Use private(set) and private dictionaries to protect accounting and concurrency invariants.

Source map

• Official Apple documentation