Editora

Congela todos os Objeto de Realm e collection emitidos pelo editor upstream

O congelamento de um Objeto de Realm faz com que ele não seja mais atualizado quando são feitas gravações no Realm e torna seguro passar livremente entre threads sem usar .threadSafeReference().

// Get a publisher for a Results
let cancellable = myResults.publisher
   // Convert to frozen Results
   .freeze()
   // Unlike live objects, frozen objects can be sent to a concurrent queue
   .receive(on: DispatchQueue.global())
   .sink { frozenResults in
       // Do something with the frozen Results
   }

Congela todos os conjuntos de alterações do Objeto de Realm emitidos pelo editor upstream.

O congelamento de um conjunto de alterações de Objeto de Realm faz com que a referência de objeto incluída não seja mais atualizada quando são feitas gravações no Realm e torna seguro passar livremente entre threads sem usar .threadSafeReference(). Ele também garante que o objeto congelado contido no changeset sempre corresponderá às alterações de propriedade , o que nem sempre é o caso ao usar referências thread-safe.

// Get a changeset publisher for an object
let cancellable = changesetPublisher(object)
   // Convert to frozen changesets
   .freeze()
   // Unlike live objects, frozen objects can be sent to a concurrent queue
   .receive(on: DispatchQueue.global())
   .sink { changeset in
       // Do something with the frozen changeset
   }

Congela todos os conjuntos de alterações da collection Realm do editor upstream.

O congelamento de um conjunto de alterações da coleção Realm faz com que a referência da coleção incluída não seja mais atualizada quando são feitas gravações no Realm e torna seguro passar livremente entre threads sem usar .threadSafeReference(). Ele também garante que a coleção congelada contida no changeset sempre corresponderá às informações de alteração, o que nem sempre é o caso ao usar referências thread-safe.

// Get a changeset publisher for a collection
let cancellable = myList.changesetPublisher
   // Convert to frozen changesets
   .freeze()
   // Unlike live objects, frozen objects can be sent to a concurrent queue
   .receive(on: DispatchQueue.global())
   .sink { changeset in
       // Do something with the frozen changeset
   }

Congela todos os conjuntos de alterações da collection Realm do editor upstream.

O congelamento de um conjunto de alterações da coleção Realm faz com que a referência da coleção incluída não seja mais atualizada quando são feitas gravações no Realm e torna seguro passar livremente entre threads sem usar .threadSafeReference(). Ele também garante que a coleção congelada contida no changeset sempre corresponderá às informações de alteração, o que nem sempre é o caso ao usar referências thread-safe.

// Get a changeset publisher for a collection
let cancellable = myMap.changesetPublisher
   // Convert to frozen changesets
   .freeze()
   // Unlike live objects, frozen objects can be sent to a concurrent queue
   .receive(on: DispatchQueue.global())
   .sink { changeset in
       // Do something with the frozen changeset
   }

Permite passar conjuntos de alterações de objetos para uma fila de despacho diferente.

Cada chamada para receive(on:) em um editor que emite objetos confinados ao thread do Realm deve ser precedida por uma chamada para .threadSafeReference(). O editor retornado lida com a lógica necessária para passar o objeto confinado ao thread para a nova fila. Somente filas de despacho em série são suportadas e o uso de outros agendadores resultará em um erro fatal.

Por exemplo, para assinar um thread em segundo plano, faça algum trabalho lá e passe o changeset de objeto para o thread principal que você pode fazer:

let cancellable = changesetPublisher(myObject)
    .subscribe(on: DispatchQueue(label: "background queue")
    .print()
    .threadSafeReference()
    .receive(on: DispatchQueue.main)
    .sink { objectChange in
        // Do things with the object on the main thread
    }

Permite passar conjuntos de alterações da collection Realm para uma fila de despacho diferente.

Cada chamada para receive(on:) em um editor que emite objetos confinados ao thread do Realm deve ser precedida por uma chamada para .threadSafeReference(). O editor retornado lida com a lógica necessária para passar o objeto confinado ao thread para a nova fila. Somente filas de despacho em série são suportadas e o uso de outros agendadores resultará em um erro fatal.

Por exemplo, para se inscrever em um tópico em segundo plano, faça algum trabalho lá e passe o collection changeset para o tópico principal que você pode fazer:

let cancellable = myCollection.changesetPublisher
    .subscribe(on: DispatchQueue(label: "background queue")
    .print()
    .threadSafeReference()
    .receive(on: DispatchQueue.main)
    .sink { collectionChange in
        // Do things with the collection on the main thread
    }

Permite passar conjuntos de alterações da collection Realm para uma fila de despacho diferente.

Cada chamada para receive(on:) em um editor que emite objetos confinados ao thread do Realm deve ser precedida por uma chamada para .threadSafeReference(). O editor retornado lida com a lógica necessária para passar o objeto confinado ao thread para a nova fila. Somente filas de despacho em série são suportadas e o uso de outros agendadores resultará em um erro fatal.

Por exemplo, para se inscrever em um tópico em segundo plano, faça algum trabalho lá e passe o collection changeset para o tópico principal que você pode fazer:

let cancellable = myCollection.changesetPublisher
    .subscribe(on: DispatchQueue(label: "background queue")
    .print()
    .threadSafeReference()
    .receive(on: DispatchQueue.main)
    .sink { collectionChange in
        // Do things with the collection on the main thread
    }

Permite passar objetos confinados ao thread para uma fila de despacho diferente.

Cada chamada para receive(on:) em um editor que emite objetos confinados por thread do Realm deve ser precedida por uma chamada para .threadSafeReference(). O editor retornado lida com a lógica necessária para passar o objeto confinado por thread para a nova fila. Somente filas de despacho em série são suportadas e o uso de outros agendadores resultará em um erro fatal.

Por exemplo, para se inscrever em um thread em segundo plano, faça algum trabalho lá e passe o objeto para o thread principal que você pode fazer:

let cancellable = publisher(myObject)
    .subscribe(on: DispatchQueue(label: "background queue")
    .print()
    .threadSafeReference()
    .receive(on: DispatchQueue.main)
    .sink { object in
        // Do things with the object on the main thread
    }

Chamar essa função em um editor que emite objetos congelados ou não gerenciados é desnecessário, mas é permitido.