I took a sample from Paul's samples to simply display a list of game scores. I understand that a struct is "real data" and a class is a reference to data. I changed the definition of the SimpleGameResult from a struct to a class.

In the example below, a score is changed in the .onAppear.

The new value is not displayed unless something else on the view is changed. The myCounter += 1 is commented out in this code, and the .onAppear score = 99 does not show in the view. Uncomment the myCounter += 1 and the 99 shows correctly since the view has changed.

if the SimpleGameResult is a struct, the .onAppear score of 99 appears correctly without the nei'cessity if changing something else in the view.

o.k. so the results isn't really changing since the score in the class is changed, but the value that should be displayed has changed, so why would the view not consider itself changed? I'm doing this in a macOS app thus the .frame for sizing

it's the concept that is escaping me and I really need an explanation please.

import SwiftUI

class SimpleGameResult {
    internal init(score: Int) {
        self.score = score
    }
    let id = UUID()
    var score: Int
}

struct ContentView: View {
    @State var results = [
        SimpleGameResult(score: 8),
        SimpleGameResult(score: 5),
        SimpleGameResult(score: 10)
    ]
    @State private var myCounter = 0
    var body: some View {
        VStack {
            Text("myCounter is \(myCounter)")
            ForEach(results, id: \.id) { result in
                Text("Result: \(result.score)")
            }
        }
        .frame(width: 200, height: 200, alignment: .center)
        .onAppear(perform: {
            results[0].score = 99
          //  myCounter += 1
        })
    }
}

Thanks @roosterboy, that is exactly what I thought was happening and I did not want to accept my understanding as a fact.

Now the problem is how do you make an array an observedobject?

I had forgotten about the observableobject since I have not used it lately, but, how do you make an array of observableobjects. I changed the previous example to the following, but I am getting the same results of not updating until something is changed on the view, ie myCounter += 1 refreshes the view, the .onappear does not.

I did read in passing one solution that @observedobject does not work on an array. Maybe that is this latest problem?

import SwiftUI

class SimpleGameResult: ObservableObject {
    internal init(score: Int) {
        self.score = score
    }
    let id = UUID()
    @Published var score: Int
}
class SimpleClass: ObservableObject {
    @Published var  scores = [
        SimpleGameResult(score: 8),
        SimpleGameResult(score: 5),
        SimpleGameResult(score: 10)
    ]
}
struct ContentView: View {
    @ObservedObject var results = SimpleClass()
    @State private var myCounter = 0
    var body: some View {
        VStack {
            Text("myCounter is \(myCounter)")
            ForEach(results.scores.indices, id: \.self) { ind in
                Text("Result: \(results.scores[ind].score)")
            }
        }
        .frame(width: 200, height: 200, alignment: .center)
        .onAppear(perform: {
            results.scores[0].score = 99
           // myCounter += 1
        })
    }
}

The easiest way to do it is to extract the code within the ForEach into its own View and pass a single SimpleGameResult object into it. Like so:

            ForEach(results.scores.indices, id: \.self) { ind in
                ReferenceRow(rowObject: results.scores[ind])
            }

struct ReferenceRow: View {
    @ObservedObject var rowObject: SimpleGameResult

    var body: some View {
        Text("Result: \(rowObject.score)")
    }
}

(I would also change @ObservedObject var results = SimpleClass() to use @StateObject unless you still need to work on iOS 13.)

But I would first ask if SimpleGameResult needs to be a class instead of a struct? Swift (and SwiftUI) encourages us to use value types as much as possible. You should start with value types and only change them to reference types if you need to.

@roosterboy interesting reading and I have a supplementary question about a class being a reference.

Imagine if I have a swift file defining a class which has variables and methods. This is instantiated in ContentView.

If I also have another view and declare a variable of the class when I navigate to that view is it acceptable to pass a reference to the view to give the functionality of the class to the new view

Example below and sorry if this is in the wrong thread.

import SwiftUI

class TestClass {
    func displayMessage() {
        print("Message")
    }
}

struct ContentView: View {

    var testClass = TestClass()

    var body: some View {
        NavigationView {
            VStack {
                NavigationLink("New View", destination: NewView(testClass: testClass))

            }
            .navigationBarTitle("Class Test")
        }
        .onAppear(perform: testClass.displayMessage)
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

import SwiftUI

struct NewView: View {

    var testClass: TestClass

    var body: some View {
        VStack {
            Text("New View")
        }
        .onAppear(perform: testClass.displayMessage)
    }
}

struct NewView_Previews: PreviewProvider {
    static var previews: some View {
        NewView(testClass: TestClass())
    }
}

@roosterboy ... that is the old "keep you views small and simple" trick. Thanks. When you only have one thing that changes, rather than an array of things that change, the world(view) is a happy thing.

This problem popped up while I was putting two classes together with inheritance. Structs work just fine if life was so simple.

@Quindownunder ... you got the concept. That is exactly what is going on here. Sure saves a lot of coding when the class functionality is just passed on. Your can do the same with a struct, they are so interchangable if you do not need one of the class features.

@Quindownunder, you could do that but you'd have to watch out for your class object being deallocated out from under you. This danger was one of the reasons why @StateObject was introduced in SwiftUI 2.0; it makes sure that a reference to the class is retained outside the view hierarchy so that it won't get deallocated and cause mysterious problems. So you would use @StateObject in whatever View "owns" that data and it will be retained even if the View struct itself is removed from memory.

@rbquick:

This problem popped up while I was putting two classes together with inheritance. Structs work just fine if life was so simple.

That's one of the great things about Swift; you can usually use structs and protocols to handle what is done with inheritance in OO languages. Really, there are far fewer places in Swift and SwiftUI where a class is needed. Working with Apple's built-in objects is the main one, e.g. subclassing UIButton or UIView to make custom buttons and views, etc.