SwiftUI中视图模型间的数据共享与修改方案咨询

你的核心问题在于当前Post是值类型（struct），修改PostUpdateViewModel中的副本不会影响PostListViewModel里的原数据，同时分页场景下不能全量刷新。以下是几种可行的解决思路：

方案一：将Post改为引用类型（ObservableObject） #

把Post从struct改为遵循ObservableObject的class，让所有视图模型共享同一个Post实例，修改属性时自动同步到列表视图。

修改Post模型 #

class Post: Codable, Identifiable, ObservableObject {
    var id: Int
    @Published var title: String
    @Published var content: String
    // 其他属性
    
    // 手动实现Codable（class默认合成可能存在问题）
    enum CodingKeys: String, CodingKey {
        case id, title, content
    }
    
    init(id: Int, title: String, content: String) {
        self.id = id
        self.title = title
        self.content = content
    }
    
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        id = try container.decode(Int.self, forKey: .id)
        title = try container.decode(String.self, forKey: .title)
        content = try container.decode(String.self, forKey: .content)
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(id, forKey: .id)
        try container.encode(title, forKey: .title)
        try container.encode(content, forKey: .content)
    }
}

调整PostUpdateViewModel #

无需维护@Published的post，直接操作共享实例：

class PostUpdateViewModel: ObservableObject {
    let post: Post
    private let apiService: APIService // 假设你有API服务类
    
    init(post: Post, apiService: APIService) {
        self.post = post
        self.apiService = apiService
    }
    
    func update() async throws {
        // 调用API更新后端数据
        let updatedPost = try await apiService.updatePost(post)
        // 更新本地实例属性，自动触发视图刷新
        post.title = updatedPost.title
        post.content = updatedPost.content
    }
}

列表视图监听单个Post变化 #

在PostListView中，监听每个Post的变化以触发列表刷新：

struct PostListView: View {
    @StateObject var viewModel = PostListViewModel()
    
    var body: some View {
        List(viewModel.posts) { post in
            NavigationLink {
                PostDetailView(post: post)
            } label: {
                VStack(alignment: .leading) {
                    Text(post.title)
                    Text(post.content)
                }
            }
            .onReceive(post.objectWillChange) { _ in
                viewModel.objectWillChange.send()
            }
        }
    }
}

方案二：共享父视图模型给子视图模型 #

保持Post为值类型，让PostUpdateViewModel持有PostListViewModel的引用，更新后直接修改父模型中的对应帖子。

调整PostUpdateViewModel #

class PostUpdateViewModel: ObservableObject {
    let post: Post
    private let parentViewModel: PostListViewModel
    private let apiService: APIService
    
    init(post: Post, parentViewModel: PostListViewModel, apiService: APIService) {
        self.post = post
        self.parentViewModel = parentViewModel
        self.apiService = apiService
    }
    
    func update() async throws {
        let updatedPost = try await apiService.updatePost(post)
        // 在父模型的数组中找到对应ID的帖子并替换
        if let index = parentViewModel.posts.firstIndex(where: { $0.id == updatedPost.id }) {
            parentViewModel.posts[index] = updatedPost
        }
    }
}

传递父视图模型到子视图 #

在PostListView跳转时传入父模型：

struct PostListView: View {
    @StateObject var viewModel = PostListViewModel()
    private let apiService = APIService()
    
    var body: some View {
        List(viewModel.posts) { post in
            NavigationLink {
                PostDetailView(post: post, parentViewModel: viewModel, apiService: apiService)
            } label: {
                // 列表项内容
            }
        }
    }
}

方案三：闭包回调通知更新 #

保持Post为值类型，通过闭包让PostUpdateViewModel完成更新后通知视图层，再由视图层更新父模型。

调整PostUpdateViewModel #

class PostUpdateViewModel: ObservableObject {
    let post: Post
    private let apiService: APIService
    var onUpdateCompleted: ((Post) -> Void)?
    
    init(post: Post, apiService: APIService) {
        self.post = post
        self.apiService = apiService
    }
    
    func update() async throws {
        let updatedPost = try await apiService.updatePost(post)
        onUpdateCompleted?(updatedPost)
    }
}

在子视图中处理回调 #

struct PostDetailView: View {
    let post: Post
    @EnvironmentObject var parentViewModel: PostListViewModel
    @StateObject private var updateViewModel: PostUpdateViewModel
    private let apiService = APIService()
    
    init(post: Post) {
        self.post = post
        self._updateViewModel = StateObject(wrappedValue: PostUpdateViewModel(post: post, apiService: apiService))
    }
    
    var body: some View {
        Button("更新帖子") {
            Task {
                do {
                    try await updateViewModel.update()
                } catch {
                    // 处理错误逻辑
                }
            }
        }
        .onAppear {
            updateViewModel.onUpdateCompleted = { [weak parentViewModel] updatedPost in
                guard let parentVM = parentViewModel else { return }
                if let index = parentVM.posts.firstIndex(where: { $0.id == updatedPost.id }) {
                    parentVM.posts[index] = updatedPost
                }
            }
        }
    }
}

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