Escribir transacciones - SDK .NET

Overview

Además de leer objetos, puedes crear, actualizar y eliminar objetos de un dominio. Dado que estas operaciones modifican el estado del dominio, las llamamos "escrituras", y todas las escrituras en el dominio deben realizarse dentro de una transacción.

Una transacción es una lista de operaciones de lectura y escritura que Realm trata como una única operación indivisible. Una transacción es una operación de todo o nada: todas las operaciones de la transacción se realizan correctamente o ninguna tiene efecto.

Un dominio solo permite una transacción abierta a la vez. El dominio bloquea otras escrituras en otros subprocesos hasta que se complete la transacción abierta. Esto garantiza que no haya condiciones de carrera al leer valores del dominio dentro de una transacción.

Cuando se completan todas las operaciones de una transacción, Realm la confirma o la cancela:

• Cuando Realm confirma una transacción, escribe todos los cambios en el disco. En el caso de los dominios sincronizados, el SDK pone el cambio en cola para su sincronización con Atlas App Services.

• Cuando Realm cancela una transacción de escritura (como cuando una operación en la transacción provoca un error), todos los cambios se descartan (o se "revierten").

Iniciar una transacción

El SDK de .NET proporciona una API sencilla que puede utilizar para la mayoría de las escrituras. Los métodos Write() y WriteAsync() envuelven todos los comandos en una sola transacción y luego confirman la transacción.

El Write() Los métodos y WriteAsync() son una forma abreviada de Async usar BeginWrite() los Transaction métodos BeginWrite() y Transaction.Commit(), y sus equivalentes. En la mayoría de los casos, cualquiera de estos dos métodos de escritura satisfará sus necesidades. Si necesita un control más preciso sobre la transacción, use con uno de estos métodos:

• Comprometerse()

• Disponer()

• Rollback()

El siguiente código muestra cómo utilizar ambos enfoques:

// Instantiate a class, as normal.
var dog = new Dog { Id = 42, Name = "Max", Age = 5 };
// Open a thread-safe transaction.
realm.Write(() =>
{
    // Add the instance to the realm.
    realm.Add(dog);
});

// Open a thread-safe transaction.
using (var transaction = realm.BeginWrite())
{
    // At this point, the TransactionState is "Running":
    // transaction.State == TransactionState.Running
    try
    {
        // Perform a write op...
        realm.Add(myDog);
        // Do other work that needs to be included in
        // this transaction
        if (transaction.State == TransactionState.Running)
        {
            transaction.Commit();
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
        // Something went wrong; roll back the transaction
        if (transaction.State != TransactionState.RolledBack &&
            transaction.State != TransactionState.Committed)
        {
            transaction.Rollback();
        }
    }
}

Comprobar el estado de una transacción

El SDK proporciona una propiedad TransactionState con el estado actual de la transacción. Puede usar TransactionState para asegurarse de no confirmar ni revertir una transacción dos veces:

// Open a thread-safe transaction.
using (var transaction = realm.BeginWrite())
{
    // At this point, the TransactionState is "Running":
    // transaction.State == TransactionState.Running
    try
    {
        // Perform a write op...
        realm.Add(myDog);
        // Do other work that needs to be included in
        // this transaction
        if (transaction.State == TransactionState.Running)
        {
            transaction.Commit();
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
        // Something went wrong; roll back the transaction
        if (transaction.State != TransactionState.RolledBack &&
            transaction.State != TransactionState.Committed)
        {
            transaction.Rollback();
        }
    }
}