No Swift imperativo, é comum usar propriedades computadas para fornecer acesso conveniente aos dados sem duplicar o estado.
Digamos que eu tenha essa classe feita para uso obrigatório do MVC:
class ImperativeUserManager {
private(set) var currentUser: User? {
didSet {
if oldValue != currentUser {
NotificationCenter.default.post(name: NSNotification.Name("userStateDidChange"), object: nil)
// Observers that receive this notification might then check either currentUser or userIsLoggedIn for the latest state
}
}
}
var userIsLoggedIn: Bool {
currentUser != nil
}
// ...
}
Se eu quiser criar um equivalente reativo ao Combine, por exemplo, para uso com o SwiftUI, posso adicionar facilmente @Published
às propriedades armazenadas para gerar Publisher
s, mas não para propriedades calculadas.
@Published var userIsLoggedIn: Bool { // Error: Property wrapper cannot be applied to a computed property
currentUser != nil
}
Existem várias soluções alternativas em que pude pensar. Eu poderia tornar minha propriedade computada armazenada e mantê-la atualizada.
Opção 1: Usando um observador de propriedades:
class ReactiveUserManager1: ObservableObject {
@Published private(set) var currentUser: User? {
didSet {
userIsLoggedIn = currentUser != nil
}
}
@Published private(set) var userIsLoggedIn: Bool = false
// ...
}
Opção 2: usando a Subscriber
na minha própria classe:
class ReactiveUserManager2: ObservableObject {
@Published private(set) var currentUser: User?
@Published private(set) var userIsLoggedIn: Bool = false
private var subscribers = Set<AnyCancellable>()
init() {
$currentUser
.map { $0 != nil }
.assign(to: \.userIsLoggedIn, on: self)
.store(in: &subscribers)
}
// ...
}
No entanto, essas soluções alternativas não são tão elegantes quanto as propriedades calculadas. Eles duplicam o estado e não atualizam as duas propriedades simultaneamente.
O que seria um equivalente adequado para adicionar a Publisher
a uma propriedade computada em Combine?
ObservableObject
. Você supõe inerentemente que um ObservableObject
objeto possa ter capacidade de mutação que, por definição, não é o caso da Propriedade Computada .