SwiftUI @State variables aren't updated

So, I still haven't figured out WHY the code posted in the question didn't work, with a pointer from @loremipsum I got a working code by using another .sheet() method, one that takes an optional Item and not a boolean flag. The code now looks like this and works, but still if anyone can explain why the posted code didn't work I'd appreciate it.

struct UsersView: View {
    @Environment(\.managedObjectContext)
    private var viewContext

    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \User.nickname, ascending: true)],
        animation: .default)
    private var users: FetchedResults<User>
    
    @State private var selectedUser : User? = nil
    
    var body: some View {
        NavigationView {
            List {
                ForEach(users) { user in
                    UserRowView(user: user)
                        .onTapGesture {
                            self.selectedUser = user
                        }
                    }.onDelete(perform: deleteItems)
                }
        }.sheet(item: $selectedUser, onDismiss: nil) { user in
            UserEditorView(user: user)
        }
    }
}

struct == immutable and SwiftUI decides when the struct gets init and reloaded

Working with code that depends on SwiftUI updating non-wrapped variables at a very specific time is not recommended. You have no control over this process.

To make your first setup work you need to use SwiftUI wrappers for the variables

.sheet(isPresented: $showUserEditor) {
            //struct == immutable SwiftUI wrappers load the entire struct when there are changes
            //With your original setup this variable gets created/set when the body is loaded so the orginal value of nil is what is seen in the next View
            UserEditorView1(userId: $selectedUserId)
        }

struct UserEditorView1: View {
    //This is what you orginal View likely looks like it won't work because of the struct being immutable and SwiftUI controlling when the struct is reloaded

    //let userId: NSManagedObjectID? <---- Depends on specific reload steps

    //To make it work you would use a SwiftUI wrapper so the variable gets updated when SwiftUI descides to update it which is invisible to the user
    @Binding var userId: NSManagedObjectID?
    //This setup though now requres you to go fetch the object somehow and put it into the View so you can edit it.
    //It is unnecessary though because SwiftUI provides the .sheet init with item where the item that is set gets passed directly vs waiting for the SwiftUi update no optionals
    var body: some View {
        Text(userId?.description ?? "nil userId")
    }
}

Your answer code doesn't work because your parameter is optional and Binding does not like optionals

struct UserEditorView2: View {
    //This is the setup that you posted in the Answer code and it doesn't work becaue of the ? Bindings do not like nil. You have to create wrappers to compensate for this
    //But unecessary because all CoreData objects are ObservableObjects so you dont need Binding here the Binding is built-in the object for editing the variables
    @Binding var user: User?
    
    var body: some View {
        TextField("nickname", text: $user.nickname)
    }
}

Now for working code with an easily editable CoreData Object

struct UsersView: View {
    @Environment(\.managedObjectContext)
    private var viewContext
    
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \User.nickname, ascending: true)],
        animation: .default)
    private var users: FetchedResults<User>
    //Your list view would use the CoreData object to trigger a sheet when the new value is available. When nil there will not be a sheet available for showing
    @State private var selectedUser : User? = nil
    
    var body: some View {
        NavigationView {
            List {
                ForEach(users) { user in
                    UserRowView(user: user)
                        .onTapGesture {
                            self.selectedUser = user
                        }
                }
            }
        }.sheet(item: $selectedUser, onDismiss: nil) { user in //This gives you a non-optional user so you don't have to compensate for nil in the next View
            UserEditorView3(user: user)
        }
    }
}

Then the View in the sheet would look like this

struct UserEditorView3: View {
    //I mentioned the ObservedObject in my comment 
    @ObservedObject var user: User
    var body: some View {
        //If your nickname is a String? you have to compensate for that optional but it is much simpler to do it from here
        TextField("nickname", text: $user.nickname.bound)
    }
}


//This comes from another very popular SO question (couldn't find it to quote it) that I could not find and is necessary when CoreData does not let you define a variable as non-optional and you want to use Binding for editing
extension Optional where Wrapped == String {
    var _bound: String? {
        get {
            return self
        }
        set {
            self = newValue
        }
    }
    public var bound: String {
        get {
            //This just give you an empty String when the variable is nil
            return _bound ?? ""
        }
        set {
            _bound = newValue.isEmpty ? nil : newValue
        }
    }
}