如何将SwiftData中两个关联子模型合并为单一排序列表？

首先先修正你模型定义中的错误：Item1和Item2里的关联对象应该是Event而非Trip，否则关联关系会失效，修正后的模型如下：

@Model
class Event: Identifiable {
    var id = UUID()
    var name: String = ""
    var dateStart: Date = Date()
    var dateEnd: Date = Date()
    
    @Relationship(deleteRule: .cascade)
    var flights: [Item1]?
    @Relationship(deleteRule: .nullify) // 根据需求选择删除规则
    var events: [Item2]?
}

@Model
class Item1: Identifiable {
    var id = UUID()
    var name: String = ""
    var dateStart: Date = Date()
    var dateEnd: Date = Date()
    
    @Relationship(inverse: \Event.flights) var event: Event?
}

@Model
class Item2: Identifiable {
    var id = UUID()
    var name: String = ""
    var address: String = ""
    var notes: String = ""
    var dateStart: Date = Date()
    var dateEnd: Date = Date()
    
    @Relationship(inverse: \Event.events) var event: Event?
}

接下来解决合并两个不同类型子模型并排序的问题，这里提供两种可行方案：

方案一：使用协议统一类型 #

1. 定义通用协议 #

创建一个包含两个子模型共同属性的协议，用于统一处理逻辑：

protocol TimelineItem: Identifiable {
    var id: UUID { get }
    var name: String { get }
    var dateStart: Date { get }
    var dateEnd: Date { get }
}

2. 让子模型遵守协议 #

修改Item1和Item2，让它们遵守上述协议：

@Model
class Item1: Identifiable, TimelineItem {
    // 原有属性保持不变
}

@Model
class Item2: Identifiable, TimelineItem {
    // 原有属性保持不变
}

3. 在视图中合并排序 #

在你的详情视图中，直接从Event的关联属性中提取数据，转换为协议类型后合并排序：

struct EventDetails: View {
    let event: Event
    
    // 合并并按dateStart排序的统一数组
    private var combinedTimelineItems: [any TimelineItem] {
        let flights = event.flights ?? []
        let events = event.events ?? []
        // 合并两个数组并转换为协议类型
        let allItems: [any TimelineItem] = flights + events
        // 按开始时间升序排序
        return allItems.sorted { $0.dateStart < $1.dateStart }
    }
    
    var body: some View {
        List {
            ForEach(combinedTimelineItems) { item in
                // 根据类型渲染不同UI
                Group {
                    if let flight = item as? Item1 {
                        FlightRow(flight: flight)
                    } else if let eventItem = item as? Item2 {
                        EventItemRow(item: eventItem)
                    }
                }
            }
        }
    }
}

// 示例行视图：展示Item1的内容
struct FlightRow: View {
    let flight: Item1
    var body: some View {
        VStack(alignment: .leading) {
            Text(flight.name)
                .font(.headline)
            Text("飞行时段: \(flight.dateStart.formatted()) - \(flight.dateEnd.formatted())")
                .font(.caption)
        }
    }
}

// 示例行视图：展示Item2的内容
struct EventItemRow: View {
    let item: Item2
    var body: some View {
        VStack(alignment: .leading) {
            Text(item.name)
                .font(.headline)
            Text(item.address)
                .font(.subheadline)
            Text("活动时段: \(item.dateStart.formatted()) - \(item.dateEnd.formatted())")
                .font(.caption)
            if !item.notes.isEmpty {
                Text(item.notes)
                    .font(.footnote)
                    .foregroundColor(.secondary)
            }
        }
    }
}

方案二：使用枚举封装类型 #

如果你觉得类型转换不够直观，可以用枚举来封装两个子模型：

1. 定义枚举类型 #

enum CombinedItem: Identifiable {
    case flight(Item1)
    case event(Item2)
    
    // 实现Identifiable协议的id属性
    var id: UUID {
        switch self {
        case .flight(let flight): return flight.id
        case .event(let event): return event.id
        }
    }
    
    // 提取共同的dateStart用于排序
    var dateStart: Date {
        switch self {
        case .flight(let flight): return flight.dateStart
        case .event(let event): return event.dateStart
        }
    }
}

2. 在视图中合并排序 #

struct EventDetails: View {
    let event: Event
    
    private var combinedItems: [CombinedItem] {
        let flights = (event.flights ?? []).map(CombinedItem.flight)
        let events = (event.events ?? []).map(CombinedItem.event)
        return (flights + events).sorted { $0.dateStart < $1.dateStart }
    }
    
    var body: some View {
        List {
            ForEach(combinedItems) { item in
                switch item {
                case .flight(let flight):
                    FlightRow(flight: flight)
                case .event(let eventItem):
                    EventItemRow(item: eventItem)
                }
            }
        }
    }
}

为什么你之前的方法行不通？ #

1. ForEach中使用&&：ForEach需要接收数组类型，而&&是布尔逻辑运算符，两者完全不兼容，这种写法从逻辑上就错误。
2. 使用两个@Query：@Query的参数需要在视图初始化阶段确定，无法直接引用视图的实例属性event；同时[Item1]和[Item2]是不同类型的数组，不能直接用+合并，必须先统一类型。

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