Vincent's questions

Observei um padrão estranho ao usar @ObservedObjecte @Published.
Eu o injeto dentro de uma SwiftUIvisualização, mas a visualização parece atualizar antes da mudança real do objeto.

Então meu @ObservedObjectnão tem o valor correto quando verifico sua @Publishedpropriedade.

Se eu adicionar um didSetcom um , objectWillChange.send()funciona como esperado.

Aqui está o código com o qual estou trabalhando:

class AuthManager: ObservableObject {
    @Published public private(set) var user: User {
        willSet { print("Will set") }
        didSet { print("Did set") }
    }
}


struct AuthView: View {
    @ObservedObject var authManager: AuthManager

    var body: some View {
        let _ = Self._printChanges()
        print("AuthManager user = \(authManager.user)")

        return (
            Text("AuthManager Test")
        )
    }
}

Quando atualizo meu objeto de usuário no AuthManager, recebo os logs na seguinte ordem:

Will set
AuthView: @self, @identity, _authManager
AuthManager user = xxx // <-- old version
Did set

O comportamento funciona como esperado se eu remover o @Publishede acionar o objectWillChange.send()no didSet.

Espero ter a nova versão quando a visualização for atualizada. Estou esquecendo de algo ou há algo que não entendi sobre ObservableObjecte @Published?

Obrigado

Meu aplicativo inclui vários widgets que indicam valores em tempo real (temperatura, uso da CPU, memória, etc....). Esses widgets são atualizados a partir de mensagens JSON recebidas por meio de um único websocket.

No momento, as atualizações são tratadas em tempo real, então atualizo meu widget assim que um novo valor é recebido.

As mensagens são as seguintes: {widget: "widgetId", value: 150}.

Meu problema é que às vezes há várias atualizações por segundo para o mesmo widget e isso faz a tela piscar e tem um custo de desempenho inútil. Quero reduzir isso apenas atrasando a atualização da IU para atualizar apenas com o último valor recebido por um período de tempo.

Gostaria de explorar as duas opções a seguir:

1. Atualize todos os widgets ao mesmo tempo uma vez a cada X segundos (mantendo apenas a atualização mais recente para cada widget e enviando todas de uma vez para a interface do usuário).

2. Atualiza um widget no máximo uma vez a cada X segundos (um debounce por canal).

Meu manipulador de soquete se parece com isto:

socket.receive(completionHandler: { [weak self] result in
    switch result {
        case .success(let message):
            switch message {
                case .data(let data):
                    guard let update = try? WidgetUpdate(serializedData: data) else {
                         print("Failed to deserialize data")
                         return
                     }
                     DispatchQueue.main.async {
                         self?.updateWidget(update: update)
                     }
                     @unknown default:
                         print("unknown")
            }
        }
    }
)

O que tentei até agora é usar algo PassthroughSubjectassim:

let subject = PassthroughSubject<WidgetUpdate, Never>()
cancellable = subject
    .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
    .sink { update in
        self?.updateWidget(update: update)
    }

// And to publish inside the publisher from the socket handler like this
subject.send(update)

O problema é que ele obviamente debounces "todas" as atualizações e não por widget.
Eu gostaria de evitar criar um PassthroughSubject por widget, pois o widget pode ser adicionado ou excluído dinamicamente e eu não quero ter que gerenciar a criação/exclusão dos publicadores associados.

Eu tenho um NSSet(from CoreData) contendo propriedades Elementa columne row(ambos Int16).
Quero converter isso com eficiência NSSetem um array de array [[Element]](seria um array de colunas e o valor seria um array de linhas nas colunas) de forma que ele lide com buracos nas coordenadas e respeite a ordem.

Por exemplo, se eu tiver os seguintes elementos:

let mySet = NSSet([
    Element(column: 1, row: 1, id: 'el1'), 
    Element(column: 3, row: 0, id: 'el2),
    Element(column: 3, row: 2, id: 'el3'),
    Element(column: 6, row: 12, id: 'el4'),
    Element(column: 6, row: 6, id: 'el5),
    Element(column: 6, row: 1, id: 'el6')
]);
// I would get an array like:
let resultArray = [
  [el1],
  [el2, el3],
  [el6, el5, el4]
]

Tentei várias soluções como Dictionary(grouping: ..), reduce, etc ... mas não consigo fazer funcionar corretamente.

Eu tenho um modelo Core Data com múltiplas propriedades e um formulário para editar todas essas propriedades.
Quero que as alterações sejam "salvas automaticamente". Assim, assim que eu alterar algo no formulário, ele será salvo em meu contexto de dados principal.

Eu me pego fazendo muitas ligações personalizadas para salvar meu contexto nas alterações, por exemplo:

TextField("My string", 
  text: Binding(
    get: {
        model.myString
    }, 
    set: { newValue in
        model.myString = newValue
        try? context.save()
    }
  )
)

Gostaria de simplificar meu código e ter uma ligação especial vinculada ao contexto de dados principais para evitar esse padrão. Como eu poderia simplificar isso?