Início / coding / Perguntas / 79262716
Accepted
bauerMusic
Asked: 2024-12-08 23:06:21 +0800 CST

SwiftUI (Mac) @Observable memory leak, relacionado a uma matriz, aciona o ciclo de vida do aplicativo

  • 772

Usar @Observableo modelo de exibição com uma coleção de matrizes, se abordado no init, acionará um segundo ciclo de vida do aplicativo quando sofrer mutação.

Quebrando:
Raiz :

@main
struct MyApp: App {
    
    var body: some Scene {
        WindowGroup {
            MainContentView()
        }
    }
}

Modelo de visualização

@Observable
class ContentViewModel {
    var items = [String]()
    
    init() {
        print("Init")
        if items.isEmpty {}
    }

    deinit {
        print("deinit")
    }

    
    func update() {
        items.append("New")
    }
}

Visualizar :

struct ContentView: View {
    
    @State var viewModel: ContentViewModel = .init()
    
    var body: some View {
        Button("Update", action: viewModel.update)
    }
}

Ao executar isso, ele imprimirá "Init" (esperado, é claro), mas clicar em "Update" aciona um ciclo de vida completo.
Ele imprimirá outro "Init". Definir um ponto de interrupção no (único) WindowGroupparará ali. O que significa (eu acho) que o todo var body: some Sceneestá sendo acionado.

  • Simplesmente removendo items.isEmpty, o problema desaparece.
  • O gráfico de memória está mostrando o ContentViewModeldobro.
  • Não há definição.
  • Só acontece com @Observable(não acontece se usar ObservableObject/ObservedObject)
swiftui

1 respostas

  1. Best Answer

    A principal diferença entre @StateObjecte @Stateé que o inicializador de propriedade de @Stateé chamado toda vez que o inicializador da visualização é chamado.

    Então, depois que viewModelele é inicializado pela primeira vez, você acaba criando uma instância temporária para ContentViewModelcada chamada subsequente ContentView.init.

    Normalmente, a instância temporária é imediatamente desinicializada, mas ainda pode afetar o desempenho se você estiver fazendo algo pesado no @Observableinicializador da classe. Isso é apontado na documentação para State.

    Uma Statepropriedade sempre instancia seu valor padrão quando o SwiftUI instancia a exibição. Por esse motivo, evite efeitos colaterais e trabalho intensivo de desempenho ao inicializar o valor padrão. Por exemplo, se uma exibição for atualizada com frequência, alocar um novo objeto padrão cada vez que a exibição for inicializada pode se tornar caro. Em vez disso, você pode adiar a criação do objeto usando o task(priority:_:) modificador, que é chamado apenas uma vez quando a exibição aparece pela primeira vez:

    struct ContentView: View {
    @State private var library: Library?


    var body: some View {
        LibraryView(library: library)
            .task {
                library = Library()
            }
    }
}

    Às vezes, uma instância extra é retida por causa de algumas peculiaridades no algoritmo do SwiftUI de criação de um gráfico de dependência. Pela minha experiência, só vi no máximo uma instância extra por @State.

    No seu caso, a linha if items.isEmpty {}acessa a propriedade observed-tracked items, e esse acesso é registrado no observationRegistrar. Isso afeta o gráfico de dependência do SwiftUI de uma forma ou de outra, e a instância não é liberada.

    Você pode resolver isso fazendo o que a documentação recomenda: tornando-o opcional e inicializando-o em taskou onAppear.

    Alternativamente, você pode usar este wrapper de propriedade do malhal .

    @MainActor
@propertyWrapper struct StateObservable<T>: DynamicProperty where T: Observable & AnyObject {
    @StateObject var storage: Storage
    
    class Storage: ObservableObject {
        @Published var object: T // @Published allows the object to be replaced and body will be called
        init(object: T) {
            self.object = object
        }
    }
    
    var wrappedValue: T {
        get {
            return storage.object
        }
        nonmutating set {
            storage.object = newValue
        }
    }
    
    // this allows $ syntax to be used in the same View where the wrapper is declared.
    var projectedValue: Bindable<T> {
        get {
            Bindable(storage.object)
        }
    }
    
    @inlinable public init(wrappedValue thunk: @autoclosure @escaping () -> T) {
        _storage = StateObject(wrappedValue: Storage(object: thunk()))
    }
}

    Este wrapper de propriedade encapsula a expressão inicializadora de propriedade em um @autoclosure, para que ele atue de forma semelhante a @StateObject.

    • 0

relate perguntas