发布者

冻结由上游发布者发出的所有 Realm 对象和 collection

冻结 Realm 对象会使其在写入 Realm 时不再进行实时更新，并且可以在不使用.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
   }

冻结由上游发布者发出的所有 Realm 对象变更集。

冻结 Realm 对象变更集会使包含的对象引用在写入 Realm 时不再实时更新，并且可以在线程之间安全地自由传递，而无需使用.threadSafeReference() 。 它还保证变更集中包含的冻结对象始终与属性更改匹配，而使用线程安全引用时并非总是如此。

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

冻结来自上游发布者的所有 Realm collection 变更集。

冻结 Realm collection 变更集会使包含的 collection 引用在写入 Realm 时不再实时更新，并且可以在不使用.threadSafeReference()的情况下在线程之间安全地自由传递。它还保证变更集中包含的冻结collection将始终与变更信息匹配，而使用线程安全引用时并非总是如此。

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

冻结来自上游发布者的所有 Realm 分段结果变更集。

冻结 Realm 分段结果变更集会使包含的分段结果引用在写入 Realm 时不再实时更新，并且可以在不使用.threadSafeReference()的情况下在线程之间安全地自由传递。 它还保证变更集中包含的冻结分段结果将始终与变更信息匹配，而使用线程安全引用时并非总是如此。

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

冻结来自上游发布者的所有 Realm collection 变更集。

冻结 Realm collection 变更集会使包含的 collection 引用在写入 Realm 时不再实时更新，并且可以在不使用.threadSafeReference()的情况下在线程之间安全地自由传递。它还保证变更集中包含的冻结collection将始终与变更信息匹配，而使用线程安全引用时并非总是如此。

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

冻结由上游发布者发出的所有 Realm 投影变更集。

冻结 Realm 投影变更集会使包含的投影引用在写入 Realm 时不再实时更新，并且可以在不使用.threadSafeReference()的情况下安全地在线程之间自由传递。 它还保证变更集中包含的冻结投影始终与属性更改匹配，而使用线程安全引用时并非总是如此。

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

允许将对象变更集传递到不同的调度队列。

每次在发出 Realm 线程限制对象的发布者上调用receive(on:)时，都必须先调用.threadSafeReference() 。 返回的发布者处理将线程限制对象传递到新队列所需的逻辑。 仅支持串行调度队列，使用其他调度器将导致致命错误。

例如，要在背景线程上订阅，请在其中执行一些操作，然后将对象变更集传递给主线程，您可以执行以下操作：

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
    }

允许将投影变更集传递到不同的调度队列。

每次在发出 Realm 线程限制投影的发布者上调用receive(on:)之前，都必须调用.threadSafeReference() 。 返回的发布者处理所需的逻辑，以将线程限制的投影传递到新队列。 仅支持串行调度队列，使用其他调度器将导致致命错误。

例如，要在背景线程上订阅，请在其中执行一些操作，然后将投影变更集传递到主线程，您可以执行以下操作：

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
    }

支持将 Realm 集合变更集传递到不同的调度队列。

每次在发出 Realm 线程限制对象的发布者上调用receive(on:)时，都必须先调用.threadSafeReference() 。 返回的发布者处理将线程限制对象传递到新队列所需的逻辑。 仅支持串行调度队列，使用其他调度器将导致致命错误。

例如，要在后台线程上订阅，请在其中执行一些操作，然后将集合变更集传递到主线程，您可以执行以下操作：

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
    }

支持将 Realm 集合变更集传递到不同的调度队列。

每次在发出 Realm 线程限制对象的发布者上调用receive(on:)时，都必须先调用.threadSafeReference() 。 返回的发布者处理将线程限制对象传递到新队列所需的逻辑。 仅支持串行调度队列，使用其他调度器将导致致命错误。

例如，要在后台线程上订阅，请在其中执行一些操作，然后将集合变更集传递到主线程，您可以执行以下操作：

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
    }

支持将 Realm 分段结果变更集传递到不同的调度队列。

每次在发出 Realm 线程限制对象的发布者上调用receive(on:)时，都必须先调用.threadSafeReference() 。 返回的发布者处理将线程限制对象传递到新队列所需的逻辑。 仅支持串行调度队列，使用其他调度器将导致致命错误。

例如，要在后台线程上订阅，请在其中执行一些操作，然后将集合变更集传递到主线程，您可以执行以下操作：

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
    }

允许将具有线程限制的对象传递到不同的调度队列。

每次在发出 Realm 线程限制对象的发布者上调用receive(on:)之前，都必须调用.threadSafeReference() 。返回的发布者会处理将线程限制对象传递到新队列所需的逻辑。 仅支持串行调度队列，使用其他调度器将导致致命错误。

例如，要在背景线程上订阅，请在其中执行一些操作，然后将对象传递给您可以执行的主线程：

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
    }

在发出冻结或非托管对象的发布者上调用此函数是不必要的，但也是允许的。