我可以在 SwiftUI 的 state 变量中使用泛型类型吗？

Question

Is there a way to use a generic type in a state variable in Swift?

I have a view which presents 3 buttons. Each button loads an array of items of either MyGenericObject<TypeA> , MyGenericObject<TypeB> or MyGenericObject<TypeC> type and the aim is to then present a list of objects from the chosen array.

But XCode throws an error when I write @State var objects: [MyGenericObject<T>]?

The error is there even when working with an individual object instead of an array, as in the following example:

struct ObjectView: View {

// I would like the following to be @State var object: MyGenericObject<T> instead...
    
@State var object: MyGenericObject<TypeA>? 
    
    var body: some View {
        
        Text("\(object?.data.name)")

// because I would then like to do something like this, if possible:

    if type(of: object) == MyGenericObject<TypeA> {
        ...show list of item of this type
    } else

    if type(of: object) == MyGenericObject<TypeB> {
        ...show list of item of this type
    }

    else {
        ...show list of item of type MyGenericObject<TypeC>
    }

// or better yet, use a switch

}

How can I use a generic type in a @State variable in SwiftUI? And is there a better way to achieve what I want?

Answer 1

I stumbled across this question and took a look at the gist. It's a little hard to tell if this is exactly what you want, but it seems like it might get you on the right path:

protocol InstrumentType {
    var name : String { get set }
    var int : Int { get set }
    var bool : Bool { get set }
}

class Instrument<T : InstrumentType>: ObservableObject {
    @Published var object: T
    
    init(object: T){
        self.object = object
    }
}

class Trumpet: NSObject, ObservableObject, InstrumentType {
    @Published var name: String
    @Published var int: Int
    @Published var bool: Bool
    
    init(name: String = "newTrumpet", int: Int = 1, bool: Bool = true){
        self.name = name
        self.int = int
        self.bool = bool
    }
}

class Guitar: NSObject, ObservableObject, InstrumentType  {
    @Published var name: String
    @Published var int: Int
    @Published var bool: Bool
    
    init(name: String = "newGuitar", int: Int = 2, bool: Bool = true){
        self.name = name
        self.int = int
        self.bool = bool
    }
}

class Clarinet: NSObject, ObservableObject, InstrumentType  {
    @Published var name: String
    @Published var int: Int
    @Published var bool: Bool
    
    init(name: String = "newClarinet", int: Int = 3, bool: Bool = true){
        self.name = name
        self.int = int
        self.bool = bool
    }
}

struct ContentView : View {
    var body: some View {
        _ContentView(instrument: Instrument(object: Trumpet(name: "testTrumpet")))
    }
}

//VIEWS
struct _ContentView<T : InstrumentType>: View {
    @StateObject var instrument: Instrument<T>
    
    var body: some View {
        InstrumentView(instrument: instrument)
            .environmentObject(instrument)
            .frame(width: 300, height: 100)
    }
}

struct InstrumentView<T : InstrumentType>: View {
    
    @ObservedObject var instrument: Instrument<T>
    
    var body: some View {
        
        VStack {
            if type(of: instrument) == Instrument<Trumpet>.self {
                Text("Instrument is a trumpet")
                Text("\(instrument.object.name)")
                Text("\(instrument.object.int)")
                Text("\(instrument.object.bool ? "true" : "false")")
            } else
            
            if type(of: instrument) == Instrument<Guitar>.self {
                Text("Instrument is a guitar")
                Text("\(instrument.object.name)")
                Text("\(instrument.object.int)")
            }
            
            else {
                Text("Instrument is a clarinet")
            }
            
            Button("Update int") {
                instrument.object.int += 1
            }
        }  
    }
}

1. Added a protocol InstrumentType that defines the available properties on each instrument -- that allowed me to get rid of the Metadata , since it was all stored on each instrument anyway

2. Constrained each generic to InstrumentType

3. I was a little confused by the @StateObject for each type of instrument -- I assumed that maybe what I did was what you were looking for (one generic @StateObject, but perhaps this is where the answer differs from the intent)

4. I was able to use environmentObject and object.name in the way you were hoping

5. Added a Button to show that the @Published properties propagate correctly.