RLMRealm

Objective-C

@interface RLMRealm : NSObject

Swift

@_nonSendable(_assumed) class RLMRealm : NSObject

一个RLMRealm实例（也称为“Realm”）代表一个 Realm 数据库。

Realm 可以存储在磁盘上（请参阅+[RLMRealm realmWithURL:] ）或内存中（请参阅RLMRealmConfiguration ）。

RLMRealm 实例在内部缓存，并且在事件循环的单次迭代内的单个线程上多次构造等效的RLMRealm对象（例如，通过使用相同的路径或标识符）通常会返回相同的RLMRealm对象。

如果您特别想要确保销毁一个RLMRealm实例（例如，如果您想打开一个 Realm，检查某些属性，然后可能删除该 Realm 文件并重新打开它），请将使用 Realm 文件的代码放在@autoreleasepool {}内，并确保没有其他强引用对其进行强引用。

警告

未冻结的RLMRealm实例受线程限制，不能跨线程或调度队列共享。尝试这样做会导致抛出异常。您必须在要与 Realm 交互的每个线程上调用此方法。对于调度队列，这意味着您必须在每个调度的区块中调用它，因为不能保证队列在同一线程上运行其所有区块。

在 GitHub 上显示

创建和初始化 Realm

+defaultRealm
获取默认 Realm 的实例。

默认 Realm 由不采用RLMRealm参数的RLMObject类方法使用，但在其他方面并不特殊。默认 Realm 作为default.realm持久保存在 iOS 上应用程序的Documents目录中、macOS 上应用程序的Application Support目录以及 tvOS 上的Cache目录中。

默认 Realm 是使用默认RLMRealmConfiguration创建的，可以通过+[RLMRealmConfiguration setDefaultConfiguration:]更改该默认值。
声明
Objective-C

+ (nonnull instancetype)defaultRealm;
Swift

class func `default`() -> Self
返回值

当前线程的默认RLMRealm实例。

在 GitHub 上显示


                    
                    
                    +defaultRealmForQueue:

获取绑定到给定队列的默认 Realm 实例。

队列绑定的 RLMRealm 不限于打开它们的线程，而是限于给定队列。可以从任何线程访问它们，前提是它是从调度到队列的块内进行的，并且通知将传递到队列而不是线程的事件循环。

Realm 只能限于串行队列。当队列限制的 RLMRealm 实例不在该队列上时，可以获取该实例，但在不首先分派到队列的情况下尝试对该实例执行任何操作都会引发不正确的线程异常。

默认 Realm 是使用默认RLMRealmConfiguration创建的，可以通过+[RLMRealmConfiguration setDefaultConfiguration:]更改该默认值。

声明

Objective-C

+ (nonnull instancetype)defaultRealmForQueue:(nonnull dispatch_queue_t)queue;

Swift

class func defaultRealm(for queue: dispatch_queue_t) -> Self

参数


                                queue

用于限制 Realm 的串行调度队列。

返回值

给定队列的默认RLMRealm实例。

在 GitHub 上显示


                    
                    
                    +realmWithConfiguration:error:

获取具有给定配置的RLMRealm实例。

声明

Objective-C

+ (nullable instancetype)
    realmWithConfiguration:(nonnull RLMRealmConfiguration *)configuration
                     error:(NSError *_Nullable *_Nullable)error;

Swift

convenience init(configuration: RLMRealmConfiguration) throws

参数

`configuration`	创建 Realm 时使用的配置对象。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

一个RLMRealm实例。

在 GitHub 上显示


                    
                    
                    +realmWithConfiguration:queue:error:

获取具有绑定到给定队列的给定配置的RLMRealm实例。

声明

Objective-C

+ (nullable instancetype)
    realmWithConfiguration:(nonnull RLMRealmConfiguration *)configuration
                     queue:(nullable dispatch_queue_t)queue
                     error:(NSError *_Nullable *_Nullable)error;

Swift

convenience init(configuration: RLMRealmConfiguration, queue: dispatch_queue_t?) throws

参数

`configuration`	创建 Realm 时使用的配置对象。
`queue`	用于限制 Realm 的串行调度队列。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

一个RLMRealm实例。

在 GitHub 上显示


                    
                    
                    +realmWithURL:

获取在指定文件 URL 持久保存的RLMRealm实例。

声明

Objective-C

+ (nonnull instancetype)realmWithURL:(nonnull NSURL *)fileURL;

Swift

convenience init(url fileURL: URL)

参数


                                fileURL

应保存 Realm 的文件的本地 URL。

返回值

一个RLMRealm实例。

在 GitHub 上显示


                    
                    
                    +asyncOpenWithConfiguration:callbackQueue:callback:

异步打开 Realm 并将其传递到给定队列上的区块。

异步打开 Realm 会在分派到给定队列之前，在背景线程上执行使 Realm 进入可用状态（例如运行可能耗时的迁移）所需的所有工作。此外，同步 Realm 会等待操作开始下载并在本地可用时所有可用的远程内容。

传递给回调函数的 Realm 被限制在回调队列中，就像使用了-[RLMRealm realmWithConfiguration:queue:error]一样。

声明

Objective-C

+ (nonnull RLMAsyncOpenTask *)
    asyncOpenWithConfiguration:(nonnull RLMRealmConfiguration *)configuration
                 callbackQueue:(nonnull dispatch_queue_t)callbackQueue
                      callback:(nonnull RLMAsyncOpenRealmCallback)callback;

Swift

class func asyncOpen(with configuration: RLMRealmConfiguration, callbackQueue: dispatch_queue_t, callback: @escaping RLMAsyncOpenRealmCallback) -> RLMAsyncOpenTask

参数

`configuration`	打开 Realm 时使用的配置对象。
`callbackQueue`	应运行回调的串行调度队列。
`callback`	回调区块。如果已成功打开 Realm，则会将其作为参数传入。否则，描述Go的`NSError`将被传递到区块。

在 GitHub 上显示


                    
                    
                    schema

Realm 使用的RLMSchema 。

声明

Objective-C

@property (nonatomic, readonly) RLMSchema *_Nonnull schema;

Swift

var schema: RLMSchema { get }

在 GitHub 上显示

inWriteTransaction
指示 Realm 当前是否正在进行写事务（write transaction）。

警告
不要简单地检查此属性，然后在需要创建、更新或删除对象时启动写事务（write transaction）。这样做可能会导致创建大量写事务（write transaction），从而降低性能。相反，总是更喜欢在单个事务期间执行多个更新。
声明
Objective-C

@property (nonatomic, readonly) BOOL inWriteTransaction;
Swift

var inWriteTransaction: Bool { get }
在 GitHub 上显示


                    
                    
                    configuration

用于创建此RLMRealm实例的RLMRealmConfiguration对象。

声明

Objective-C

@property (nonatomic, readonly) RLMRealmConfiguration *_Nonnull configuration;

Swift

var configuration: RLMRealmConfiguration { get }

在 GitHub 上显示

isEmpty
指示此 Realm 是否包含任何对象。
声明
Objective-C

@property (nonatomic, readonly) BOOL isEmpty;
Swift

var isEmpty: Bool { get }
在 GitHub 上显示
frozen
指示此 Realm 是否已冻结。

看
-[RLMRealm freeze]
声明
Objective-C

@property (nonatomic, readonly, getter=isFrozen) BOOL frozen;
Swift

var isFrozen: Bool { get }
在 GitHub 上显示
-freeze
返回此 Realm 的冻结（不可变）快照。

冻结 Realm 是特定版本 Realm 数据的不可变快照视图。与普通的 RLMRealm 实例不同，它不会实时更新以反映对 Realm 进行的写入，并且可以从任何线程进行访问。写入冻结的 Realm 是不被允许的，尝试开始写事务（write transaction）会引发异常。

从冻结 Realm 读取的所有对象和collection也将被冻结。
声明
Objective-C

- (nonnull RLMRealm *)freeze;
Swift

func freeze() -> RLMRealm
在 GitHub 上显示
-thaw
返回此 Realm 的实时引用。

从返回的 Realm 读取的所有对象和collection将不再被冻结。如果尚未冻结，此方法将返回self 。
声明
Objective-C

- (nonnull RLMRealm *)thaw;
Swift

func thaw() -> RLMRealm
在 GitHub 上显示

文件管理


                    
                    
                    -writeCopyToURL:encryptionKey:error:

将压缩且可选加密的 Realm 副本写入给定的本地 URL。

目标文件不能是已经存在的文件。

请注意，如果从写事务（write transaction）中调用此方法，则写入当前数据，而不是提交上一个写事务（write transaction）时的点的数据。

声明

Objective-C

- (BOOL)writeCopyToURL:(nonnull NSURL *)fileURL
         encryptionKey:(nullable NSData *)key
                 error:(NSError *_Nullable *_Nullable)error;

Swift

func writeCopy(to fileURL: URL, encryptionKey key: Data?) throws

参数

`fileURL`	用于保存 Realm 的本地 URL。
`key`	用于加密新文件的可选 64 字节加密密钥。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

YES 如果已将 Realm 成功写入磁盘，则为NO ，如果发生错误。

在 GitHub 上显示


                    
                    
                    -writeCopyForConfiguration:error:

将 Realm 副本写入给定配置指定的给定位置。

如果提供的配置派生自RLMUser ，则将在启用同步功能的情况下复制此 Realm。

目标文件不能是已经存在的文件。

声明

Objective-C

- (BOOL)writeCopyForConfiguration:(nonnull RLMRealmConfiguration *)configuration
                            error:(NSError *_Nullable *_Nullable)error;

Swift

func writeCopy(for configuration: RLMRealmConfiguration) throws

参数

`configuration`	Realm 配置。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

YES 如果已将 Realm 成功写入磁盘，则为NO ，如果发生错误。

在 GitHub 上显示


                    
                    
                    +fileExistsForConfiguration:

检查给定配置的 Realm 文件是否存在于磁盘本地。

对于非同步、非内存中的 Realm，这相当于-[NSFileManager.defaultManager fileExistsAtPath:config.path] 。对于同步 Realm，它负责根据服务器、虚拟路径和用户计算磁盘上的实际路径，就像打开 Realm 时所做的那样。

声明

Objective-C

+ (BOOL)fileExistsForConfiguration:(nonnull RLMRealmConfiguration *)config;

Swift

class func fileExists(for config: RLMRealmConfiguration) -> Bool

参数


                                config

要检查是否存在的 Realm 配置。

返回值

如果磁盘上存在给定配置的 Realm 文件，则为 YES，否则为 NO。

在 GitHub 上显示


                    
                    
                    +deleteFilesForConfiguration:error:

删除给定配置的本地 Realm 文件和关联的临时文件。

这会删除“域”、“.note”和“. Management”文件，这些文件是通过打开具有给定配置的 Realm 创建的。它不会删除锁文件（该文件不包含持久数据，并且每次打开 Realm 文件时都会从头开始重新创建）。

Realm 当前不得在任何线程或其他进程中打开。如果是，则返回 NO 并报告错误 RLMErrorAlreadyOpen。在删除操作发生时，尝试在另一个线程上打开 Realm 会被阻塞（然后创建一个新的 Realm，然后再将其打开）。

如果 Realm 不存在，则会返回NO并报告错误 NSFileNoSuchFileError；

声明

Objective-C

+ (BOOL)deleteFilesForConfiguration:(nonnull RLMRealmConfiguration *)config
                              error:(NSError *_Nullable *_Nullable)error;

Swift

class func deleteFiles(for config: RLMRealmConfiguration) throws -> Bool

参数


                                config

标识要删除的 Realm 的 Realm 配置。

返回值

如果删除了任何文件，则为“是”，否则为“否”。

在 GitHub 上显示

在 Realm 变更时接收通知


                    
                    
                    -addNotificationBlock:

为此 Realm 中的变更添加通知处理程序，并返回通知令牌。

在当前线程或其他线程上提交每个写事务（write transaction）后，会调用通知处理程序。

在添加处理程序块的同一线程上调用处理程序块，并且只能在当前位于事件循环内的线程上添加处理程序块。除非您专门在背景线程上创建并运行事件循环，否则这通常只是主线程。

该区块具有以下定义：

typedef void(^RLMNotificationBlock)(RLMNotification notification, RLMRealm *realm);

它接收以下参数：

NSString * notification ：传入通知的名称。请参阅RLMRealmNotification以了解有关发送哪些通知的信息。
RLMRealm *域：发生此通知的 Realm。

声明

Objective-C

- (nonnull RLMNotificationToken *)addNotificationBlock:
    (nonnull RLMNotificationBlock)block;

Swift

func addNotificationBlock(_ block: @escaping RLMNotificationBlock) -> RLMNotificationToken

参数


                                block

为处理 Realm 通知而调用的区块。

返回值

只要您希望继续接收变更通知，就必须保留的令牌对象。

在 GitHub 上显示

写入 Realm

-beginWriteTransaction
在 Realm 上开始写事务。

每个 Realm 文件一次只能打开一个写事务（write transaction）。写事务（write transaction）不能嵌套，尝试在已处于写事务（write transaction）中的 Realm 上开始写事务（write transaction）会引发异常。beginWriteTransactionRLMRealm从其他线程或其他进程中同一 Realm 文件的实例调用会受到阻塞，直到当前写事务（write transaction）完成或取消。

在开始写事务（write transaction）之前， beginWriteTransaction会将RLMRealm实例更新到最新的 Realm 版本，就好像已调用refresh一样，并生成通知（如适用）。如果 Realm 已经是最新的，则此操作无效。

让写事务（write transaction）跨越事件循环的多个周期很少是一个好主意，但如果您确实希望这样做，则需要确保参与写事务（write transaction）的 Realm 保持活动状态，直到提交写事务（write transaction）。
声明
Objective-C

- (void)beginWriteTransaction;
Swift

func beginWriteTransaction()
在 GitHub 上显示
-commitWriteTransaction
提交当前写事务（write transaction）中的所有写操作，并结束事务。

保存更改后，将同步调用在此特定RLMRealm实例上注册的所有通知块。在其他线程或collection上注册的通知块将被异步调用。如果您不想收到此写事务的特定通知，请参阅commitWriteTransactionWithoutNotifying:error: 。

如果没有足够的磁盘空间来保存所做的写入，或者由于意外的 I/O 错误，此方法可能会失败。此版本的方法会在发生错误时引发异常。如果您希望处理错误，请使用带有NSError输出参数的版本。

警告
此方法只能在写事务（write transaction）期间调用。
声明
Objective-C

- (void)commitWriteTransaction;
在 GitHub 上显示


                    
                    
                    -commitWriteTransaction:

提交当前写事务（write transaction）中的所有写操作，并结束事务。

保存更改后，将同步调用在此特定RLMRealm实例上注册的所有通知块。在其他线程或collection上注册的通知块将被异步调用。如果您不想收到此写事务的特定通知，请参阅commitWriteTransactionWithoutNotifying:error: 。

如果没有足够的磁盘空间来保存所做的写入，或者由于意外的 I/O 错误，此方法可能会失败。

警告

此方法只能在写事务（write transaction）期间调用。

声明

Objective-C

- (BOOL)commitWriteTransaction:(NSError *_Nullable *_Nullable)error;

Swift

func commitWriteTransaction() throws

参数


                                error

如果发生错误，则返回时包含描述问题的NSError对象。如果您对可能的错误不感兴趣，请传入NULL 。

返回值

事务是否成功。

在 GitHub 上显示


                    
                    
                    -commitWriteTransactionWithoutNotifying:error:

提交当前写事务（write transaction）中的所有写操作，而不将更改通知特定通知块。

保存更改后，将同步调用在此特定RLMRealm实例上注册的所有通知块。在其他线程或collection上注册的通知块将安排异步调用。

您可以通过传入特定通知块的关联通知令牌来跳过通知特定通知块有关此写事务（write transaction）中所做更改的操作。当写事务（write transaction）正在保存用户界面中已进行的更改并且您不希望让通知块尝试重新应用相同的更改时，这主要有用。

传递给此方法的令牌必须用于此特定RLMRealm实例的通知。使用此方法无法跳过不同线程的通知。

如果没有足够的磁盘空间来保存所做的写入，或者由于意外的 I/O 错误，此方法可能会失败。

警告

此方法只能在写事务（write transaction）期间调用。

声明

Objective-C

- (BOOL)commitWriteTransactionWithoutNotifying:
            (nonnull NSArray<RLMNotificationToken *> *)tokens
                                         error:(NSError *_Nullable *_Nullable)
                                                   error;

Swift

func commitWriteTransactionWithoutNotifying(_ tokens: [RLMNotificationToken]) throws

参数

`tokens`	一个通知令牌数组，通过添加回调而返回，您不希望收到有关此写事务（write transaction）中所做更改的通知。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

事务是否成功。

在 GitHub 上显示

-cancelWriteTransaction
恢复当前写事务（write transaction）期间进行的所有写入并结束事务。

这会将 Realm 中的所有对象回滚到写事务（write transaction）开始时的状态，然后结束事务。

这会恢复已删除对象的数据，但不会恢复失效的对象实例。任何添加到 Realm 中的RLMObject都将失效，而不是变为非托管状态。给定以下代码：
```
ObjectType *oldObject = [[ObjectType objectsWhere:@"..."] firstObject];
ObjectType *newObject = [[ObjectType alloc] init];

[realm beginWriteTransaction];
[realm addObject:newObject];
[realm deleteObject:oldObject];
[realm cancelWriteTransaction];
```
oldObject和newObject都会为isInvalidated返回YES ，但重新运行提供oldObject的查询将再次返回有效对象。

在事务期间修改的任何对象上的 KVO 观察者都会收到有关更改回其初始值的通知，但已取消的写事务（write transaction）不会生成其他通知。

警告
此方法只能在写事务（write transaction）期间调用。
声明
Objective-C

- (void)cancelWriteTransaction;
Swift

func cancelWriteTransaction()
在 GitHub 上显示
-transactionWithBlock:
在写事务（write transaction）中执行给定区块中包含的操作。

看
[RLMRealm transactionWithoutNotifying:block:error:]
声明
Objective-C

- (void)transactionWithBlock:(nonnull void (^)(void))block;
在 GitHub 上显示


                    
                    
                    -transactionWithBlock:error:

在写事务（write transaction）中执行给定区块中包含的操作。

看

[RLMRealm transactionWithoutNotifying:block:error:]

声明

Objective-C

- (BOOL)transactionWithBlock:(nonnull void (^)(void))block
                       error:(NSError *_Nullable *_Nullable)error;

Swift

func transaction(_ block: () -> Void) throws

在 GitHub 上显示


                    
                    
                    -transactionWithoutNotifying:block:

在写事务（write transaction）中执行给定区块中包含的操作。

看

[RLMRealm transactionWithoutNotifying:block:error:]

声明

Objective-C

- (void)transactionWithoutNotifying:
            (nonnull NSArray<RLMNotificationToken *> *)tokens
                              block:(nonnull void (^)(void))block;

Swift

func transactionWithoutNotifying(_ tokens: [RLMNotificationToken], block: () -> Void)

在 GitHub 上显示


                    
                    
                    -transactionWithoutNotifying:block:error:

在写事务（write transaction）中执行给定区块中包含的操作。

写事务（write transaction）不能嵌套，尝试在已经参与写事务（write transaction）的 Realm 上执行写事务（write transaction）会引发异常。从其他线程中的实例RLMRealm调用transactionWithBlock:将受阻，直到当前写事务（write transaction）完成。

在开始写事务（write transaction）之前， transactionWithBlock:会将RLMRealm实例更新到最新的 Realm 版本，就好像已调用refresh一样，并生成通知（如适用）。如果 Realm 已经是最新的，则此操作无效。

传递给此方法的令牌必须用于此特定RLMRealm实例的通知。使用此方法无法跳过不同线程的通知。

声明

Objective-C

- (BOOL)transactionWithoutNotifying:
            (nonnull NSArray<RLMNotificationToken *> *)tokens
                              block:(nonnull void (^)(void))block
                              error:(NSError *_Nullable *_Nullable)error;

Swift

func transactionWithoutNotifying(_ tokens: [RLMNotificationToken], block: () -> Void, error: ()) throws

参数

`tokens`	一个通知令牌数组，通过添加回调而返回，您不希望收到有关此写事务（write transaction）中所做更改的通知。
`block`	包含要执行的操作的区块。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

事务是否成功。

在 GitHub 上显示

isPerformingAsynchronousWriteOperations
指示 Realm 当前是否正在执行异步写入操作。在调用beginAsyncWriteTransaction 、 commitAsyncWriteTransaction或asyncTransactionWithBlock:后，该状态将变为“是”，并保持如此状态，直到所有计划的异步写入工作完成。

警告
如果此值为YES ，则在计划工作完成之前，关闭 Realm 或使 Realm 失效的操作将被阻止。
声明
Objective-C

@property (nonatomic, readonly) BOOL isPerformingAsynchronousWriteOperations;
Swift

var isPerformingAsynchronousWriteOperations: Bool { get }
在 GitHub 上显示


                    
                    
                    -beginAsyncWriteTransaction:

开始异步写事务（write transaction）。此函数在背景线程上异步开始写事务（write transaction），然后在事务开始后调用原始线程或队列上的区块。与beginWriteTransaction不同，如果另一个线程当前处于写事务（write transaction）中，则这不会阻塞调用线程，并且始终会立即返回。多次调用此函数（或执行异步写事务（write transaction）的其他函数）会将要调用的区块按照排队的顺序进行排队。这包括来自写事务（write transaction）内部的调用，与同步事务不同，这种调用是允许的。

声明

Objective-C

- (RLMAsyncTransactionId)beginAsyncWriteTransaction:
    (nonnull void (^)(void))block;

Swift

func beginAsyncWriteTransaction(_ block: @escaping () -> Void) -> RLMAsyncTransactionId

参数


                                block

包含要在写事务（write transaction）中执行的操作的区块。block应以调用commitAsyncWriteTransaction 、 commitWriteTransaction或cancelWriteTransaction结束。在没有这些调用的情况下返回相当于调用cancelWriteTransaction 。

返回值

标识异步事务的 ID，可在调用区块以取消区块的待调用之前将其传递给cancelAsyncTransaction: 。

在 GitHub 上显示


                    
                    
                    -commitAsyncWriteTransaction:allowGrouping:

异步提交写事务（write transaction）。调用立即返回，允许调用者继续操作，同时在专用背景线程上执行 I/O。无论写事务（write transaction）是使用beginWriteTransaction还是beginAsyncWriteTransaction开始，都可以使用此选项。

声明

Objective-C

- (RLMAsyncTransactionId)commitAsyncWriteTransaction:
                             (nullable void (^)(NSError *_Nullable))
                                 completionBlock
                                       allowGrouping:(BOOL)allowGrouping;

Swift

@_unsafeInheritExecutor func commitAsyncWriteTransaction(_ completionBlock: (((any Error)?) -> Void)?, allowGrouping: Bool) -> RLMAsyncTransactionId

参数

`completionBlock`	提交完成或因错误而失败后，将在源线程或队列上调用的区块。
`allowGrouping`	如果`YES` ，则对`commitAsyncWriteTransaction:`的多个顺序调用可以一起批处理，并在一个群组中持久保存到稳定存储中。这提高了写入性能，尤其是当批处理的单个事务很小时。在事件发生崩溃或电源故障的情况下，所有的事务都将丢失，或者没有，而不是通常保证在提交调用返回后立即持久保存数据。

返回值

在调用完成区块之前，可以将标识异步事务提交的 ID 传递给cancelAsyncTransaction: ，以取消该区块的待处理调用。请注意，这不会取消提交本身。

在 GitHub 上显示


                    
                    
                    -commitAsyncWriteTransaction:

声明

Objective-C

- (RLMAsyncTransactionId)commitAsyncWriteTransaction:
    (nonnull void (^)(NSError *_Nullable))completionBlock;

Swift

func commitAsyncWriteTransaction(_ completionBlock: @escaping ((any Error)?) -> Void) -> RLMAsyncTransactionId

参数


                                completionBlock

提交完成或因错误而失败后，将在源线程或队列上调用的区块。

返回值

在调用完成区块之前，可以将标识异步事务提交的 ID 传递给cancelAsyncTransaction: ，以取消该区块的待处理调用。请注意，这不会取消提交本身。

在 GitHub 上显示

-commitAsyncWriteTransaction
异步提交写事务（write transaction）。调用立即返回，允许调用者继续操作，同时在专用背景线程上执行 I/O。无论写事务（write transaction）是使用beginWriteTransaction还是beginAsyncWriteTransaction开始，都可以使用此选项。
声明
Objective-C

- (RLMAsyncTransactionId)commitAsyncWriteTransaction;
Swift

func commitAsyncWriteTransaction() -> RLMAsyncTransactionId
返回值

在调用完成区块之前，可以将标识异步事务提交的 ID 传递给cancelAsyncTransaction: ，以取消该区块的待处理调用。请注意，这不会取消提交本身。

在 GitHub 上显示


                    
                    
                    -cancelAsyncTransaction:

取消异步事务的排队区块。这可以取消传递给异步开始或异步提交的区块。取消开始会完全取消该事务，而取消提交只是取消对完成回调的调用，提交仍然会发生。事务只能在调用区块之前取消，并且从区块内调用cancelAsyncTransaction:属于不操作操作。

声明

Objective-C

- (void)cancelAsyncTransaction:(RLMAsyncTransactionId)asyncTransactionId;

Swift

func cancelAsyncTransaction(_ asyncTransactionId: RLMAsyncTransactionId)

参数


                                asyncTransactionId

来自beginAsyncWriteTransaction:或commitAsyncWriteTransaction:的事务 ID。

在 GitHub 上显示


                    
                    
                    -asyncTransactionWithBlock:onComplete:

异步执行写事务（write transaction）中给定区块中包含的操作。写事务（write transaction）异步开始，就像调用beginAsyncWriteTransaction:一样，默认情况下，事务在区块完成后异步提交。您还可以在区块中显式调用commitWriteTransaction或cancelWriteTransaction来同步提交或取消写事务（write transaction）。

声明

Objective-C

- (RLMAsyncTransactionId)
    asyncTransactionWithBlock:(nonnull void (^)(void))block
                   onComplete:
                       (nullable void (^)(NSError *_Nonnull))completionBlock;

Swift

func asyncTransaction(_ block: @escaping () -> Void, onComplete completionBlock: ((any Error) -> Void)? = nil) -> RLMAsyncTransactionId

参数

`block`	包含要执行的操作的区块。
`completionBlock`	提交完成或因错误而失败后，将在源线程或队列上调用的区块。

返回值

标识异步事务的 ID，可在调用区块以取消区块的待调用之前将其传递给cancelAsyncTransaction: 。

在 GitHub 上显示


                    
                    
                    -asyncTransactionWithBlock:

声明

Objective-C

- (RLMAsyncTransactionId)asyncTransactionWithBlock:
    (nonnull void (^)(void))block;

Swift

func asyncTransaction(_ block: @escaping () -> Void) -> RLMAsyncTransactionId

参数


                                block

包含要执行的操作的区块。

返回值

标识异步事务的 ID，可在调用区块以取消区块的待调用之前将其传递给cancelAsyncTransaction: 。

在 GitHub 上显示

-refresh
更新 Realm 和由 Realm 托管的未完成对象，使其点向最新数据。

如果 Realm 的版本确实发生了更改，则将发送 Realm 和 collection 通知以反映这些更改。这可能需要一些时间，因为collection通知是在背景线程上准备的。因此，不建议在主线程上调用此方法。
声明
Objective-C

- (BOOL)refresh;
Swift

func refresh() -> Bool
返回值

Realm 是否有任何更新。请注意，即使实际没有更改数据，也可能会返回YES 。

在 GitHub 上显示
autorefresh
将此属性设置为YES ，以便在其他线程中发生更改时自动更新此 Realm。

如果设置为YES （默认），则在其他线程上所做的更改将在提交更改后的下一个事件循环周期反映在此 Realm 中。如果设置为NO ，则必须手动对 Realm 调用-refresh来进行更新，从而获取最新数据。

请注意，背景情况下，事件循环没有活动的事件循环，即使将autorefresh设置为YES ，您也需要手动调用-refresh才能更新到最新版本。

即使启用了此属性，您仍然可以随时调用-refresh以在自动刷新之前更新 Realm。

即使禁用了自动刷新，写事务（write transaction）仍始终会将 Realm 推进到最新版本，并在提交时生成本地通知。

在没有任何强引用的 Realm 上禁用autorefresh不会产生任何影响，并且autorefresh将在下次创建 Realm 时恢复为YES 。这通常无关紧要，因为它意味着无需刷新任何内容（因为托管RLMObject 、 RLMArray和RLMResults RLMRealm.defaultRealm.autorefresh = NO管理它们的 Realm 具有强引用），但这意味着在application:didFinishLaunchingWithOptions:以及后来存储 Realm 对象将不起作用。

默认值为 YES。
声明
Objective-C

@property (nonatomic) BOOL autorefresh;
Swift

var autorefresh: Bool { get set }
在 GitHub 上显示
-invalidate
使 Realm 托管的所有RLMObject 、 RLMResults 、 RLMLinkingObjects和RLMArray失效。

Realm 对其访问的数据版本持有读锁（read lock），因此在不同线程上对该 Realm 所做的更改不会修改或删除该 Realm 看到的数据。调用此方法会释放读锁（read lock），从而允许以后的写事务（write transaction）重用磁盘上使用的空间，而不是增加文件。在您之前从 Realm 读取不再需要的数据的背景线程上执行长时间阻塞操作之前，应先调用此方法。

当前线程上从此RLMRealm实例获取的所有RLMObject 、 RLMResults和RLMArray实例都会失效。不能使用RLMObject和RLMArray 。 RLMResults将变空。 Realm 本身仍然有效，并且下次从 Realm 读取数据时会隐式开始新的读取事务。

在没有从 Realm 读取任何数据的情况下，或者在从 Realm 读取任何数据之前，连续多次调用此方法是不执行任何操作的。
声明
Objective-C

- (void)invalidate;
Swift

func invalidate()
在 GitHub 上显示

访问对象


                    
                    
                    -resolveThreadSafeReference:

返回与首次创建RLMThreadSafeReference时引用的对象相同的对象，但已解析为该线程的当前 Realm。如果在创建引用后删除了该对象，则返回nil 。

警告

RLMThreadSafeReference对象最多必须解析一次。无法解析RLMThreadSafeReference将导致 Realm 的源版本被固定，直到引用被解除分配。如果多次解析引用，则会引发异常。

警告

无法在写事务（write transaction）中调用。

注意

如果源 Realm 的版本高于此版本，则将刷新此 Realm。

看

+[RLMThreadSafeReference referenceWithThreadConfined:]

声明

Objective-C

- (nullable id)resolveThreadSafeReference:
    (nonnull RLMThreadSafeReference *)reference;

参数


                                reference

对要在此 Realm 中解析的线程对象的线程安全引用。

在 GitHub 上显示

在 Realm 中添加和删除对象


                    
                    
                    -addObject:

将对象添加到 Realm。

添加后，该对象将被视为由 Realm 托管。可以使用RLMRealm和RLMObject的子类上的objectsWhere:选择器来检索它。

添加后，此对象引用的所有子关系（如果尚未添加到 Realm 中）也将添加到 Realm 中。

如果该对象或任何相关对象已由不同的 Realm 托管，则会引发异常。使用-[RLMObject createInRealm:withObject:]将托管对象的副本插入到不同的 Realm 中。

要添加的对象必须有效，并且之前不能从 Realm 中删除（即 isInvalidated必须为NO ）。

警告

此方法只能在写事务（write transaction）期间调用。

声明

Objective-C

- (void)addObject:(nonnull RLMObject *)object;

Swift

func add(_ object: RLMObject)

参数


                                object

要添加到此 Realm 的对象。

在 GitHub 上显示


                    
                    
                    -addObjects:

将collection中的所有对象添加到 Realm 中。

这相当于为集合中的每个对象调用addObject: 。

警告

此方法只能在写事务（write transaction）期间调用。

看

addObject:

声明

Objective-C

- (void)addObjects:(nonnull id<NSFastEnumeration>)objects;

Swift

func addObjects(_ objects: any NSFastEnumeration)

参数


                                objects

一个可枚举集合，例如NSArray 、 RLMArray或RLMResults ，包含要添加到 Realm 的 Realm 对象。

在 GitHub 上显示


                    
                    
                    -addOrUpdateObject:

在 Realm 中添加或更新现有对象。

提供的对象必须具有指定的主键。如果 Realm 中不存在具有相同主键值的对象，则插入该对象。否则，现有对象将更新为任何更改的值。

与addObject:一样，该对象不能已由其他 Realm 托管。使用-[RLMObject createOrUpdateInRealm:withValue:]将值复制到不同的 Realm。

如果object上的某个属性或 KVC 值的值为 nil，并且它对应于正在更新的现有对象上的可空属性，则该可空属性将设置为 nil。

警告

此方法只能在写事务（write transaction）期间调用。

声明

Objective-C

- (void)addOrUpdateObject:(nonnull RLMObject *)object;

Swift

func addOrUpdate(_ object: RLMObject)

参数


                                object

要添加或更新的对象。

在 GitHub 上显示


                    
                    
                    -addOrUpdateObjects:

将collection中的所有对象添加或更新到 Realm 中。

这相当于为集合中的每个对象调用addOrUpdateObject: 。

警告

此方法只能在写事务（write transaction）期间调用。

看

addOrUpdateObject:

声明

Objective-C

- (void)addOrUpdateObjects:(nonnull id<NSFastEnumeration>)objects;

Swift

func addOrUpdateObjects(_ objects: any NSFastEnumeration)

参数


                                objects

一个可枚举的collection，例如NSArray 、 RLMArray或RLMResults ，包含要在 Realm 中添加或更新的 Realm 对象。

在 GitHub 上显示


                    
                    
                    -deleteObject:

从 Realm 中删除对象。对象一旦被删除，即被视为失效。

警告

此方法只能在写事务（write transaction）期间调用。

声明

Objective-C

- (void)deleteObject:(nonnull RLMObject *)object;

Swift

func delete(_ object: RLMObject)

参数


                                object

要删除的对象。

在 GitHub 上显示


                    
                    
                    -deleteObjects:

从 Realm 中删除一个或多个对象。

这相当于为集合中的每个对象调用deleteObject: 。

警告

此方法只能在写事务（write transaction）期间调用。

看

deleteObject:

声明

Objective-C

- (void)deleteObjects:(nonnull id<NSFastEnumeration>)objects;

Swift

func deleteObjects(_ objects: any NSFastEnumeration)

参数


                                objects

一个可枚举的collection，例如NSArray 、 RLMArray或RLMResults ，包含要从 Realm 中删除的对象。

在 GitHub 上显示

-deleteAllObjects
从 Realm 中删除所有对象。

警告

此方法只能在写事务（write transaction）期间调用。

看

deleteObject:
声明
Objective-C

- (void)deleteAllObjects;
Swift

func deleteAllObjects()
在 GitHub 上显示

同步订阅

subscriptions
表示此域的活动订阅，可用于添加/删除/更新和搜索Flexible Sync订阅。从本地或基于分区的配置 Realm 获取订阅会引发异常。
声明
Objective-C

@property (nonatomic, readonly, nonnull) RLMSyncSubscriptionSet *subscriptions;
Swift

var subscriptions: RLMSyncSubscriptionSet { get }
在 GitHub 上显示

迁移


                    
                    
                    +schemaVersionAtURL:encryptionKey:error:

返回给定本地 URL 的 Realm 的模式版本。

声明

Objective-C

+ (uint64_t)schemaVersionAtURL:(nonnull NSURL *)fileURL
                 encryptionKey:(nullable NSData *)key
                         error:(NSError *_Nullable *_Nullable)error;

参数

`fileURL`	Realm 文件的本地 URL。
`key`	用于加密文件的 64 字节密钥，如果未加密，则为`nil` 。
`error`	如果发生错误，则返回时包含描述问题的`NSError`对象。如果您对可能的错误不感兴趣，请传入`NULL` 。

返回值

位于fileURL的 Realm 版本，如果无法读取该版本，则为RLMNotVersioned 。

在 GitHub 上显示


                    
                    
                    +performMigrationForConfiguration:error:

在给定路径上的 Realm 上执行给定 Realm 配置的迁移区块。

首次打开 Realm 时会自动调用此方法，无需显式调用。您可以选择调用此方法来精确控制执行迁移的时间和方式。

看

RLMMigration

声明

Objective-C

+ (BOOL)performMigrationForConfiguration:
            (nonnull RLMRealmConfiguration *)configuration
                                   error:(NSError *_Nullable *_Nullable)error;

Swift

class func performMigration(for configuration: RLMRealmConfiguration) throws

参数


                                configuration

用于打开和迁移 Realm 的 Realm 配置。

返回值

应用迁移时发生的错误（如有）。

在 GitHub 上显示

不可用的方法

-init
不可用

使用 +defaultRealm、+realmWithConfiguration: 或 +realmWithURL:。

RLMRealm 实例由 Realm 内部缓存，无法直接创建。

使用+[RLMRealm defaultRealm] 、 +[RLMRealm realmWithConfiguration:error:]或+[RLMRealm realmWithURL]获取对 RLMRealm 的引用。
声明
Objective-C

- (nonnull instancetype)init;
在 GitHub 上显示
+new
不可用

使用 +defaultRealm、+realmWithConfiguration: 或 +realmWithURL:。

RLMRealm 实例由 Realm 内部缓存，无法直接创建。

使用+[RLMRealm defaultRealm] 、 +[RLMRealm realmWithConfiguration:error:]或+[RLMRealm realmWithURL]获取对 RLMRealm 的引用。
声明
Objective-C

+ (nonnull instancetype)new;
在 GitHub 上显示

同步

syncSession
获取此 Realm 使用的 RLMSyncSession。如果这不是同步 Realm，则将为 nil。
声明
Objective-C

@property (nonatomic, readonly, nullable) RLMSyncSession *syncSession;
Swift

var syncSession: RLMSyncSession? { get }
在 GitHub 上显示