SwiftUI多Sheet弹窗冲突求助：自动触发Sheet无法堆叠

SwiftUI原生的.sheet修饰器存在层级限制，同一个View层级下的多个Sheet无法叠加显示，只能显示最后一个绑定的Sheet。如果要实现叠加，常规做法是将后续Sheet嵌套到前一个Sheet的View内部，但在大型项目中这种操作繁琐且不易维护。以下是两种可行的解决方案：

方案一：基于环境对象的全局Sheet调度 #

通过创建一个全局的Sheet管理器，统一维护所有Sheet的显示栈，并将Sheet的修饰器放在App的根View层级，这样无论当前处于哪个Sheet页面，都能触发新的Sheet叠加显示。

1. 创建Sheet管理器 #

import SwiftUI

class SheetManager: ObservableObject {
    // 用数组维护Sheet显示栈，数组最后一个元素为当前显示的Sheet
    @Published var presentedSheets: [SheetType] = []
    
    // 定义所有需要显示的Sheet类型
    enum SheetType: Identifiable {
        case sheet1
        case sheet2
        case autoTriggeredSheet // 自动触发的Sheet
        
        var id: String {
            switch self {
            case .sheet1: return "sheet1"
            case .sheet2: return "sheet2"
            case .autoTriggeredSheet: return "autoSheet"
            }
        }
    }
    
    // 弹出指定Sheet
    func present(_ sheet: SheetType) {
        presentedSheets.append(sheet)
    }
    
    // 关闭当前最上层Sheet
    func dismiss() {
        _ = presentedSheets.popLast()
    }
    
    // 关闭所有Sheet
    func dismissAll() {
        presentedSheets.removeAll()
    }
}

2. 在App根View注入管理器并绑定Sheet #

@main
struct YourApp: App {
    @StateObject private var sheetManager = SheetManager()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(sheetManager)
                // 绑定数组最后一个元素，实现自动切换显示的Sheet
                .sheet(item: $sheetManager.presentedSheets.last) { sheet in
                    switch sheet {
                    case .sheet1:
                        Sheet1View()
                    case .sheet2:
                        Sheet2View()
                    case .autoTriggeredSheet:
                        AutoTriggeredSheetView()
                    }
                }
        }
    }
}

3. 在任意View中调用Sheet #

无论是用户主动触发还是自动触发，都可以通过环境对象调用管理器的方法：

// 普通View中打开Sheet
struct ContentView: View {
    @EnvironmentObject private var sheetManager: SheetManager
    
    var body: some View {
        VStack {
            Button("打开Sheet1") {
                sheetManager.present(.sheet1)
            }
        }
    }
}

// Sheet内部打开新Sheet
struct Sheet1View: View {
    @EnvironmentObject private var sheetManager: SheetManager
    
    var body: some View {
        VStack {
            Text("Sheet 1")
            Button("打开Sheet2") {
                sheetManager.present(.sheet2)
            }
        }
    }
}

// 自动触发Sheet的场景
struct SomeBusinessView: View {
    @EnvironmentObject private var sheetManager: SheetManager
    
    var body: some View {
        Text("业务页面")
            .onAppear {
                // 页面加载完成自动弹出Sheet
                sheetManager.present(.autoTriggeredSheet)
            }
    }
}

这个方案完全遵循SwiftUI的响应式设计，无需嵌套.sheet修饰器，适合大多数项目场景。

方案二：基于UIKit的原生Sheet叠加 #

利用UIKit原生的presentViewController方法支持Sheet叠加的特性，通过UIViewRepresentable封装成SwiftUI可用的组件，实现更灵活的Sheet调度。

1. 封装UIKit SheetPresenter #

import SwiftUI

class SheetPresenterUIKit: UIViewController {
    // 弹出SwiftUI View作为Sheet
    func presentSheet<Content: View>(_ content: Content) {
        let hostingVC = UIHostingController(rootView: content)
        hostingVC.modalPresentationStyle = .pageSheet // 保持SwiftUI Sheet的样式
        present(hostingVC, animated: true)
    }
}

struct SheetPresenter: UIViewRepresentable {
    typealias UIViewType = UIView
    let coordinator: Coordinator
    
    func makeUIView(context: Context) -> UIView {
        let view = UIView()
        let presenter = SheetPresenterUIKit()
        coordinator.presenter = presenter
        view.addSubview(presenter.view)
        presenter.view.frame = view.bounds
        return view
    }
    
    func updateUIView(_ uiView: UIView, context: Context) {}
    
    func makeCoordinator() -> Coordinator {
        coordinator
    }
    
    class Coordinator {
        var presenter: SheetPresenterUIKit?
        
        // 对外暴露的弹出方法
        func present<Content: View>(_ content: Content) {
            presenter?.presentSheet(content)
        }
    }
}

2. 在SwiftUI中使用 #

struct ContentView: View {
    @StateObject private var coordinator = SheetPresenter.Coordinator()
    
    var body: some View {
        VStack {
            Button("打开Sheet1") {
                coordinator.present(Sheet1View(coordinator: coordinator))
            }
        }
        // 将Presenter放在背景中，确保全局可用
        .background(SheetPresenter(coordinator: coordinator))
    }
}

struct Sheet1View: View {
    let coordinator: SheetPresenter.Coordinator
    
    var body: some View {
        VStack {
            Text("Sheet 1")
            Button("打开Sheet2") {
                coordinator.present(Sheet2View())
            }
        }
    }
}

// 自动触发场景
struct AutoTriggerView: View {
    let coordinator: SheetPresenter.Coordinator
    
    var body: some View {
        Text("自动触发页面")
            .onAppear {
                coordinator.present(Sheet2View())
            }
    }
}

这个方案绕过了SwiftUI的层级限制，支持无限叠加Sheet，适合需要高度自定义Sheet行为的复杂场景。

内容的提问来源于stack exchange，提问作者Mohamed Emad Hegab