复杂或共享SwiftData查询应放置在何处？

苹果官方文档里讲了在View内用@Query做基础查询，但遇到复杂逻辑或需要跨View复用的场景，完全不用在每个View里重复写代码，下面是几种实用方案：

1. 把查询逻辑封装到@Model类中 #

可以在你的@Model类里定义静态方法或计算属性，直接返回查询所需的Predicate、SortDescriptor组合，这样所有View都能直接复用这些逻辑，和模型强绑定，维护起来很方便。

举个例子：

@Model
class Todo {
    var title: String
    var isCompleted: Bool
    var createdAt: Date
    
    // 封装已完成任务的查询条件
    static var completedTodos: (predicate: Predicate<Todo>, sort: [SortDescriptor<Todo>]) {
        let predicate = #Predicate<Todo> { $0.isCompleted == true }
        let sort = [SortDescriptor(\Todo.createdAt, order: .reverse)]
        return (predicate, sort)
    }
}

// 在View里使用
struct CompletedTodosView: View {
    @Query(filter: Todo.completedTodos.predicate, sort: Todo.completedTodos.sort)
    private var completedTodos: [Todo]
    
    var body: some View {
        List(completedTodos) { todo in
            Text(todo.title)
        }
    }
}

2. 用专门的查询服务类封装复杂逻辑 #

如果查询涉及多个模型、需要额外的数据转换，或者逻辑特别复杂，适合单独写一个查询服务类，把所有查询逻辑集中管理，多个View依赖这个服务即可。

示例：

class TodoQueryService {
    // 封装带日期范围的复杂查询
    func todosCreatedBetween(_ start: Date, _ end: Date) -> (predicate: Predicate<Todo>, sort: [SortDescriptor<Todo>]) {
        let predicate = #Predicate<Todo> {
            $0.createdAt >= start && $0.createdAt <= end && !$0.isCompleted
        }
        let sort = [SortDescriptor(\Todo.title)]
        return (predicate, sort)
    }
    
    // 甚至可以直接返回处理后的数组（需要拿到ModelContext）
    func getOverdueTodos(context: ModelContext) -> [Todo] {
        let predicate = #Predicate<Todo> { $0.dueDate < Date() && !$0.isCompleted }
        do {
            return try context.fetch(FetchDescriptor<Todo>(predicate: predicate))
        } catch {
            return []
        }
    }
}

// 在View里使用
struct OverdueTodosView: View {
    @Environment(\.modelContext) private var context
    private let queryService = TodoQueryService()
    
    // 方式1：用@Query
    @Query private var overdueTodos: [Todo]
    
    init() {
        let queryConfig = queryService.todosCreatedBetween(Date.distantPast, Date())
        _overdueTodos = Query(filter: queryConfig.predicate, sort: queryConfig.sort)
    }
    
    // 方式2：直接调用服务获取数据
    var body: some View {
        List(queryService.getOverdueTodos(context: context)) { todo in
            Text(todo.title)
        }
    }
}

3. 用ViewModifier封装查询+UI逻辑 #

如果查询和特定的UI展示逻辑绑定（比如列表样式、空状态），可以写一个自定义ViewModifier，把@Query和UI处理逻辑打包，让需要的View直接应用这个modifier。

示例：

struct TodoListViewModifier: ViewModifier {
    let predicate: Predicate<Todo>
    let sort: [SortDescriptor<Todo>]
    
    @Query private var todos: [Todo]
    
    init(predicate: Predicate<Todo>, sort: [SortDescriptor<Todo>]) {
        self.predicate = predicate
        self.sort = sort
        _todos = Query(filter: predicate, sort: sort)
    }
    
    func body(content: Content) -> some View {
        if todos.isEmpty {
            Text("暂无任务")
        } else {
            List(todos) { todo in
                HStack {
                    Text(todo.title)
                    Spacer()
                    Image(systemName: todo.isCompleted ? "checkmark.circle.fill" : "circle")
                }
            }
        }
    }
}

// 扩展View方便调用
extension View {
    func todoList(predicate: Predicate<Todo>, sort: [SortDescriptor<Todo>]) -> some View {
        modifier(TodoListViewModifier(predicate: predicate, sort: sort))
    }
}

// 在View里使用
struct HomeView: View {
    var body: some View {
        NavigationStack {
            VStack {
                Text("未完成任务")
                    .font(.headline)
                // 直接应用modifier
                Color.clear
                    .todoList(predicate: #Predicate<Todo> { !$0.isCompleted }, sort: [SortDescriptor(\Todo.createdAt)])
            }
        }
    }
}

总结 #

• 绝对不推荐在每个View重复写查询逻辑，不仅冗余还容易出错；
• 简单的模型相关查询，直接封装到@Model类的静态成员里最方便；
• 复杂跨模型查询或需要数据处理的，用查询服务类集中管理；
• 和UI绑定的查询，用ViewModifier封装能减少UI层重复代码。

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