Solución:
@Objetoobservado
Cuando una vista crea la suya propia @ObservedObject Por ejemplo, se vuelve a crear cada vez que una vista se descarta y se vuelve a dibujar:
struct ContentView: View {
@ObservedObject var viewModel = ViewModel()
}
Por el contrario, un @State variable voluntad guardar su valor cuando se vuelve a dibujar una vista.
@StateObject
A @StateObject es una combinación de @ObservedObject y @State – la instancia del ViewModel se mantendrá y reutilizará incluso después de descartar y volver a dibujar una vista:
struct ContentView: View {
@StateObject var viewModel = ViewModel()
}
Rendimiento
Aunque un @ObservedObject puede afectar el rendimiento si la vista se ve obligada a recrear un objeto de gran peso con frecuencia, no debería importar mucho cuando el @ObservedObject no es complejo.
Cuándo usar @ObservedObject
Puede parecer que ahora no hay razón para usar un @ObserverObject, entonces, ¿cuándo debería usarse?
Debe usar @StateObject para cualquier propiedad observable que inicialice en la vista que lo usa. Si la instancia de ObservableObject se crea externamente y se pasa a la vista que la usa, marque su propiedad con @ObservedObject.
Tenga en cuenta que hay demasiados casos de uso posibles y, a veces, puede ser deseado para recrear una propiedad observable en su Vista. En ese caso, es mejor utilizar un @ObservedObject.
Enlaces útiles:
- ¿Cuál es la diferencia entre @StateObject y @ObservedObject?
- ¿Qué es el contenedor de propiedad @StateObject?
La documentación de Apple explicó por qué inicializar con ObservedObject es inseguro.
SwiftUI puede crear o recrear una vista en cualquier momento, por lo que es importante que inicializar una vista con un conjunto de entradas dado siempre resulte en la misma vista. Como resultado, no es seguro crear un objeto observado dentro de una vista.
La solucion es StateObject.
Al mismo tiempo, la documentación nos mostró cómo debemos crear modelos de datos en una vista (o aplicación / escena) cuando puede aferrarse a la verdad y pasarla a otra vista.
struct LibraryView: View {
@StateObject var book = Book() // Hold on to the 1 truth
var body: some View {
BookView(book: book) // Pass it to another view
}
}
struct BookView: View {
@ObservedObject var book: Book // From external source
}
Aunque la respuesta de pawello2222 ha explicado muy bien las diferencias cuando la propia vista crea su modelo de vista, es importante tener en cuenta las diferencias cuando el modelo de vista se inyecta en la vista.
Cuando inyecta el modelo de vista en la vista, siempre que el modelo de vista sea un tipo de referencia, no hay diferencias entre @ObservedObject y @StateObject, dado que el objeto que inyectó el modelo de vista en su vista también debe contener una referencia al modelo de vista, por lo tanto, el modelo de vista no se destruye cuando se vuelve a dibujar la vista secundaria.
class ViewModel: ObservableObject {}
struct ParentView: View {
@ObservedObject var viewModel = ViewModel()
var body: some View {
ChildView(viewModel: viewModel) // You inject the view model into the child view
}
}
// Even if `ChildView` is discarded/redrawn, `ViewModel` is kept in memory, since `ParentView` still holds a reference to it - `ViewModel` is only released and hence destroyed when `ParentView` is destroyed/redrawn.
struct ChildView: View {
@ObservedObject var viewModel: ViewModel
}