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 Objeto de Realm changeset 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 quando se usam referências seguras de thread.

// 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 collection do Realm faz com que a referência da collection incluída não seja mais atualizada quando as gravações são feitas 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 seguras de thread.

// 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 de resultados seccionados do Realm do editor upstream.

O congelamento de um conjunto de alterações de resultados seccionados do Realm faz com que a referência de resultados seccionados incluídos não seja mais atualizada quando são feitas gravações no Realm e o torna seguro para passar livremente entre threads sem usar .threadSafeReference(). Ele também garante que os resultados seccionados congelados contidos no changeset sempre corresponderão às informações de alteração, o que nem sempre é o caso ao usar referências seguras de thread.

// Get a changeset publisher for the sectioned results
let cancellable = mySectionedResults.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 collection do Realm faz com que a referência da collection incluída não seja mais atualizada quando as gravações são feitas 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 seguras de thread.

// 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
   }

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

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

// Get a changeset publisher for an projection
let cancellable = changesetPublisher(projection)
   // Convert to frozen changesets
   .freeze()
   // Unlike live projections, frozen projections 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 de projeção para uma fila de despacho diferente.

Cada chamada para receive(on:) em um editor que emite projeção confinada de thread do Realm deve ser precedida por uma chamada para .threadSafeReference(). O editor retornado lida com a lógica necessária para passar a projeção confinada de 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 changeset de projeção para o thread principal que você pode fazer:

let cancellable = changesetPublisher(myProjection)
    .subscribe(on: DispatchQueue(label: "background queue")
    .print()
    .threadSafeReference()
    .receive(on: DispatchQueue.main)
    .sink { projectionChange in
        // Do things with the projection 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 conjuntos de alterações de resultados seccionados do 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 = mySectionedResults.changesetPublisher
    .subscribe(on: DispatchQueue(label: "background queue")
    .print()
    .threadSafeReference()
    .receive(on: DispatchQueue.main)
    .sink { sectionedResultsChange in
        // Do things with the sectioned results 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.