StoreKit Product.products(for:)调用异常，Task.detached可解决——原因何在？

问题背景 #

在SwiftUI应用中使用StoreKit实现内购时，遇到Product.products(for:)返回空数组的异常，无错误抛出且App Store Connect配置确认无误。

原实现代码 #

struct ContentView: View {
    @State private var status: Status = .idle
    
    var body: some View {
        switch status {
        case .idle:
            ProgressView()
                .task {
                    await load()
                }
        case .loading:
            ProgressView()
        case .success(let products):
            Text("\(products.count)")
        case .failure(let error):
            Text(error.localizedDescription)
        }
    }
    
    private func load() async {
        do {
            self.status = .loading
            let products = try await Product.products(for: ["com.example.app.productId"])
            self.status = .success(products: products)
        } catch {
            self.status = .failure(error: error)
        }
    }
    
    private enum Status {
        case idle
        case loading
        case success(products: [Product])
        case failure(error: Error)
    }
}

上述代码中load()无报错但始终返回空数组，尝试用Task.detached包裹逻辑后问题解决，修改后代码如下：

修改后代码 #

private func load() async {
    await Task.detached {
        do {
            await MainActor.run {
                self.status = .loading
            }
            let products = try await Product.products(for: ["com.example.app.productId"])
            await MainActor.run {
                self.status = .success(products: products)
            }
        } catch {
            await MainActor.run {
                self.status = .failure(error: error)
            }
        }
    }.value
}

问题咨询 #

1. 为何原load()实现无法获取产品，而Task.detached包裹后可解决？
2. 该解决方案是否存在潜在缺陷或意外副作用？
3. Swift并发下处理该场景是否有更规范、健壮的方式？

解答 #

1. 原实现失效原因 #

原load()方法在.task修饰符的任务中调用，.task默认运行在主Actor上下文。StoreKit的Product.products(for:)虽为异步方法，但部分底层逻辑对运行上下文有隐性要求——主Actor环境下可能因主线程优先级限制、或StoreKit内部线程绑定逻辑，导致产品请求无法正常完成，最终返回空数组（无错误抛出是因为StoreKit未触发错误路径，仅返回空结果）。

Task.detached会将任务调度到非主Actor的后台并发上下文，脱离主线程限制后，StoreKit请求逻辑能正常执行，从而正确获取产品列表。

2. 当前方案的潜在缺陷 #

• 不必要的上下文切换：每次修改@State都用MainActor.run包裹，会增加额外线程切换开销，频繁状态更新场景下可能影响性能。
• 任务生命周期脱离视图：Task.detached创建的独立任务不绑定视图生命周期，若视图在请求完成前销毁，任务仍会继续执行，后续更新已释放的视图状态可能引发崩溃或无效操作。
• 代码冗余：重复的MainActor.run包裹降低代码可读性，提升维护成本。

3. 更规范的实现方式 #

方式一：用nonisolated分离请求与主Actor上下文

将产品请求逻辑标记为nonisolated，确保其运行在后台上下文，同时安全更新主Actor状态：

private func load() async {
    await MainActor.run {
        self.status = .loading
    }
    
    do {
        let products = try await fetchProducts()
        await MainActor.run {
            self.status = .success(products: products)
        }
    } catch {
        await MainActor.run {
            self.status = .failure(error: error)
        }
    }
}

// 标记为nonisolated，强制方法在后台并发上下文执行
nonisolated private func fetchProducts() async throws -> [Product] {
    return try await Product.products(for: ["com.example.app.productId"])
}

方式二：绑定视图生命周期的普通Task

使用普通Task绑定视图生命周期（视图销毁时自动取消任务），并显式切换上下文执行请求：

private func load() async {
    await MainActor.run {
        self.status = .loading
    }
    
    let task = Task {
        // 显式切换到后台上下文执行请求
        return try await Task.detached {
            try await Product.products(for: ["com.example.app.productId"])
        }.value
    }
    
    do {
        let products = try await task.value
        await MainActor.run {
            self.status = .success(products: products)
        }
    } catch {
        await MainActor.run {
            self.status = .failure(error: error)
        }
    }
}

方式三：用@MainActor简化状态更新

将状态更新逻辑统一放在主Actor中，请求逻辑自动调度到合适的后台上下文，代码更简洁：

struct ContentView: View {
    @State private var status: Status = .idle
    
    var body: some View {
        switch status {
        case .idle:
            ProgressView()
                .task {
                    await load()
                }
        case .loading:
            ProgressView()
        case .success(let products):
            Text("\(products.count)")
        case .failure(let error):
            Text(error.localizedDescription)
        }
    }
    
    private func load() async {
        setStatus(.loading)
        
        do {
            let products = try await Product.products(for: ["com.example.app.productId"])
            setStatus(.success(products: products))
        } catch {
            setStatus(.failure(error: error))
        }
    }
    
    // @MainActor标记确保状态更新在主线程执行
    @MainActor private func setStatus(_ newStatus: Status) {
        self.status = newStatus
    }
    
    private enum Status {
        case idle
        case loading
        case success(products: [Product])
        case failure(error: Error)
    }
}

这种方式既保证状态更新的线程安全，又让Product.products(for:)自动调度到后台上下文执行，避免手动切换上下文的冗余代码。

内容的提问来源于stack exchange，提问作者AntonioWar