swift Task/Async 未在后台运行并阻塞主线程

问：

我正在尝试创建一个提要，但现在使用来自 JSON 的模拟数据。但是，它非常慢。

以下是我对提要的看法

struct FeedView: View {
    
    @StateObject private var viewModel = FeedViewModel()
    @State private var isFeedSelected: Bool = true

    var body: some View {
        NavigationView {
            ScrollView {
                LazyVStack {
                    if(isFeedSelected) {
                        ForEach(viewModel.feed) { post in
                            PostItemView(item: post)
                        }
                    } else {
                        ForEach(viewModel.classFeed) { classItem in
                            Text(classItem.userName)
                        }
                    }
                }
            }
            .padding([.top], 10)
            .task {
                if(isFeedSelected) {
                    await viewModel.getFeed()
                } else {
                    await viewModel.getClasses()
                }
            }

ViewModel 如下所示：

final class FeedViewModel: ObservableObject {
    
    var feedUseCase: FeedUseCase

    @Published var feed: [FeedItemEntity] = []
    @Published var classFeed: [ClassItemEntity] = []
    
    @Published var state: FeedState = .na
    
    @Published var hasError: Bool = false

    init() {
        self.feedUseCase = FeedUseCase.shared
        setupErrorSubscription()
    }
    
    func getFeed() async {
        Task.detached {
            let result = await self.feedUseCase.getFeed()
            switch(result) {
            case .success(let feed):
                self.feed = feed
            case .failure(let error):
                self.feed = []
                self.hasError = true
            }
        }
    }
    
    func getClasses() async {
        Task.detached {
            let result = await self.feedUseCase.getClasses()
            switch(result) {
            case .success(let classes):
                self.classFeed = classes
            case .failure(let error):
                self.classFeed = []
                self.hasError = true
            }
        }
        
    }
    
}

用例是这样做的：

enum UseCaseError: Error{
    case networkError, decodingError
}

final class FeedUseCase {
    
    static let shared = FeedUseCase()
    
    let repository: FeedRepositoryProtocol
    
    init() {
        self.repository = FeedRepository.shared
    }
    
    func getFeed() async -> Result<[FeedItemEntity], UseCaseError> {
        do {
            let feed = try await repository.getFeed()
            return .success(feed)
        } catch (let error) {
            switch(error){
                case APIServiceError.decodingError:
                    return .failure(.decodingError)
                default:
                    return .failure(.networkError)
                }
            
        }
        
    }

最后，repo 只是这样做：

func getFeed() async throws -> [FeedItemEntity] {
        return try await service.getFeed()
    }

然后按如下方式提供服务：

func getFeed() async throws -> [FeedItemEntity] {
        guard let url = Bundle(for: MockedFeedService.self).url(forResource: "basic-test-feed-response",withExtension: "json"),
              let data = try? Data(contentsOf: url) else {
            throw APIServiceError.badUrl
        }
            
        guard let result = try? JSONDecoder().decode([FeedItemEntity].self, from: data) else {
            throw APIServiceError.decodingError
        }
        
        return result
    }

据我所知，循环似乎经常被调用，我认为它可能会影响性能。该应用程序非常非常慢。ForEach

我习惯于在 Android 上开发，协程机制通常在后台运行，但似乎在 iOS 上，这些调用更复杂，或者我只是遗漏了一些东西。

知道如何使应用程序高效流畅吗？

谢谢