Como posso usar metatipos para mostrar uma visualização no SwiftUI?

Para mostrar as visualizações no local, você pode simplesmente usar uma enumeração que esteja em conformidade com :View.

Na sua visualização principal, você cria uma instância dessa enumeração e define seu valor usando os botões para qualquer um dos casos disponíveis na enumeração.

Aqui está um exemplo prático:

import SwiftUI

enum ViewPresenter: View {
    case view1, view2, view3, view4
    
    var body: some View {
        switch self {
            case .view1:
                View1()
            case .view2:
                View2()
            case .view3:
                View3()
            case .view4:
                View4()
        }
    }
}

struct ShowViewsDemo: View {
    @State var presentView: ViewPresenter?

    var body: some View {
        VStack {
            if presentView != nil {
                //Show selected view
                presentView
                    .foregroundStyle(.white)
                
                    //Close button as overlay
                    .overlay(alignment: .topTrailing) {
                        Button {
                            presentView = nil
                        } label: {
                            Image(systemName: "xmark.circle.fill")
                                .font(.title2)
                        }
                        .padding(.horizontal)
                        .tint(.white)
                    }
            }
            else {
                //Show placeholder
                ContentUnavailableView {
                    Label("No view selected", systemImage: "eye")
                } description: {
                    Text("Tap any of the buttons to select and show a view.")
                }
            }
            
            Spacer() // push buttons to the bottom
            
            //Buttons
            HStack {
                Button ("View1") {
                    presentView = .view1
                }
                Button ("View2") {
                    presentView = .view2
                }
                Button ("View3") {
                    presentView = .view3
                }
                Button ("View4") {
                    presentView = .view4
                }
            }
            .padding()
            .buttonStyle(.bordered)
        }
        .animation(.smooth, value: presentView)
    }
}

struct View1: View {
    
    var body: some View {
        
        VStack {
            Text("View 1")
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.green)
    }
}

struct View2: View {
    
    var body: some View {
        
        VStack {
            Text("View 2")

        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.orange)
    }
}

struct View3: View {
    
    var body: some View {
        
        VStack {
            Text("View 3")
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.blue)
    }
}

struct View4: View {
    
    var body: some View {
        
        VStack {
            Text("View 4")
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(.pink)
    }
}

#Preview {
    ShowViewsDemo()
}

Isso não é algo idiomático para se fazer no SwiftUI. Se você só quer reduzir a desordem, eu sugeriria usar a switche um enumvalor para representar cada visualização.

enum ShowableView {
    case one, two, three, four
}

@State private var shownView: ShowableView?

var body: some View {
    switch shownView {
    case .one: View1()
    case .two: View2()
    case .three: View3()
    case .four: View4()
    case nil:
        VStack {
            Button("Show View1") {
                shownView = .one
            }
            Button("Show View2") {
                shownView = .two
            }
            Button("Show View3") {
                shownView = .three
            }
            Button("Show View4") {
                shownView = .four
            }
        }
    }
}

Se você quiser remover até mesmo os caserótulos, você pode escrever uma visualização que mostre uma visualização específica com base em um Intíndice, mas eu consideraria essa uma maneira pior de escrever isso do que switchcom enumerações.

struct ViewSelector<Content: View>: View {
    @Binding var selection: Int?
    let content: Content
    
    init(selection: Binding<Int?>, @ViewBuilder content: () -> Content) {
        self._selection = selection
        self.content = content()
    }
    
    var body: some View {
        Group(subviews: content) { subviews in
            if let selection {
                subviews[selection]
            }
        }
    }
}

struct ContentView: View {
    @State private var shownView: Int?
    
    var body: some View {
        if shownView == nil {
            ViewSelector(selection: $shownView) {
                View1()
                View2()
                View3()
                View4()
            }
        } else {
            VStack {
                Button("Show View1") {
                    shownView = 0
                }
                Button("Show View2") {
                    shownView = 1
                }
                Button("Show View3") {
                    shownView = 2
                }
                Button("Show View4") {
                    shownView = 3
                }
            }
        }
    }
}

Se você realmente quiser armazenar um metatipo, você precisaria usar AnyView, o que pode ser problemático . Essa abordagem só funcionaria com tipos de visualização que têm um inicializador sem parâmetros, o que limita muito sua utilidade em comparação ao uso de um switch, ou mesmo o ViewSelectoracima.

Primeiro você codificaria o requisito do inicializador sem parâmetros em um protocolo,

protocol DirectlyInitializableView: View {
    init()
}

extension DirectlyInitializableView {
    static func make() -> AnyView { AnyView(Self()) }
}

Você pode então armazenar um (any DirectlyInitializableView.Type)?.

@State private var shownView: (any DirectlyInitializableView.Type)?

var body: some View {
    if let shownView {
        shownView.make()
    } else {
        VStack {
            // assuming these views all conform to DirectlyInitializableView
            Button ("Show View1") {
                shownView = View1.self
            }
            Button ("Show View2") {
                shownView = View2.self
            }
            Button ("Show View3") {
                shownView = View3.self
            }
            Button ("Show View4") {
                shownView = View4.self
            }
        }
    }
}

Além de enum da resposta aceita, você pode usar algo assim:

struct ContentView: View {
    @State private var shownView: (any View)?

    var body: some View {
        if let shownView {
            AnyView(shownView)
        } else {
            VStack {
                Button("Show View1") {
                    shownView = View1()
                }
                Button("Show View2") {
                    shownView = View2()
                }
                Button("Show View3") {
                    shownView = View3()
                }
                Button("Show View4") {
                    shownView = View4()
                }
            }
        }
    }
}

Mas ainda assim, enum é o preferido.