Client Resets - .NET SDK

Recover Unsynced Local Changes

En un restablecimiento de cliente que no implique un cambio de esquema importante, el SDK integra objetos creados localmente que no se sincronizaron antes del restablecimiento del cliente. Las siguientes reglas determinan cómo se resuelven los conflictos cuando tanto el backend como el cliente realizan cambios en el mismo objeto:

• Si se elimina un objeto en el servidor, pero se modifica en el cliente en recuperación, la eliminación tiene prioridad y el cliente descarta la actualización.

• Si se elimina un objeto en el cliente recuperando, pero no en el servidor, el cliente aplicará la instrucción de borrado.

• En el caso de actualizaciones conflictivas en el mismo campo, se aplica la actualización del cliente.

There are two client reset handlers that try to automatically recover the unsycned local data: RecoverOrDiscardUnsyncedChangesHandler and RecoverUnsyncedChangesHandler.

var conf = new FlexibleSyncConfiguration(user)
{
    ClientResetHandler = new RecoverOrDiscardUnsyncedChangesHandler
    {
        // The following callbacks are optional
        OnBeforeReset = (beforeReset) =>
        {
            // Executed before the client reset begins
            // Can be used to notify the user that a reset is going
            // to happen
        },
        OnAfterRecovery = (beforeReset, afterReset) =>
        {
            // Executed after the client reset is complete
            // Can be used to notify the user that the reset is done
        },
        OnAfterDiscard = (beforeReset, afterReset) =>
        {
            // Executed if the automatic recovery has failed
            // but the DiscardUnsyncedChanges fallback has completed
            // successfully
        },
        ManualResetFallback = (err) =>
        {
            // Automatic reset failed; handle the reset manually here
        }
    }
};

var conf = new FlexibleSyncConfiguration(user)
{
    ClientResetHandler = new RecoverUnsyncedChangesHandler
    {
        // The following callbacks are optional
        OnBeforeReset = (beforeReset) =>
        {
            // Executed before the client reset begins
            // Can be used to notify the user that a reset is going
            // to happen
        },
        OnAfterReset = (beforeReset, afterReset) =>
        {
            // Executed after the client reset is complete
            // Can be used to notify the user that the reset is done
        },
        ManualResetFallback = (err) =>
        {
            // Automatic reset failed; handle the reset manually here
        }
    }
};

Descartar cambios no sincronizados

Esta estrategia elimina permanentemente todos los cambios locales no sincronizados realizados desde la última sincronización exitosa. Si elige usar DiscardUnsyncedChangesHandler un, el SDK restaura el archivo de dominio local a un estado sincronizable sin cerrar el dominio y manteniendo las notificaciones funcionando correctamente. Si este proceso falla, se recurre a una estrategia de restablecimiento manual que se explica en la sección "Recuperación manual". Este controlador proporciona los siguientes métodos de devolución de llamada:

• OnBeforeReset, which the SDK invokes prior to the client reset. You can use this callback to notify the user before the reset begins.

• OnAfterReset, que el SDK invoca solo si el restablecimiento se completa correctamente. Puede usarlo para notificar al usuario cuando se complete el restablecimiento.

• ManualResetFallback, que el SDK invoca si la restauración falla. La lógica aquí debe ser similar a la descrita para un ManualRecoveryHandler.

The following example shows how you might implement a DiscardUnsyncedChangesHandler:

{
    var config = new FlexibleSyncConfiguration(user);
    config.ClientResetHandler = new DiscardUnsyncedChangesHandler()
    {
        // The following callbacks are optional
        OnBeforeReset = (beforeReset) =>
        {
            // Executed before the client reset begins
            // Can be used to notify the user that a reset is going
            // to happen
        },
        OnAfterReset = (beforeReset, afterReset) =>
        {
            // Executed after the client reset is complete
            // Can be used to notify the user that the reset is done
        },
        ManualResetFallback = (err) =>
        {
            // Automatic reset failed; handle the reset manually here
        }
    };
    try
    {
        var realm = await Realm.GetInstanceAsync(config);
    }
    catch (Exception ex)
    {
        Console.WriteLine($@"Error creating or opening the
            realm file. {ex.Message}");
    }

Manual Recovery

In most cases, you should use one of the other strategies for client resets. For those infrequent cases where you need to customize your data recovery process, select the ManualRecoveryHandler handler.

Within the ManualRecoveryHandler, you dispose the existing realm, and then call the InitiateClientReset() method.

The following example demonstrates implementing the ManualRecoveryHandler:

private void SetupRealm()
{
    var config = new FlexibleSyncConfiguration(user);
    config.ClientResetHandler =
        new ManualRecoveryHandler(HandleClientResetError);
    var realm = await Realm.GetInstanceAsync(config);
}

private void HandleClientResetError(ClientResetException clientResetException)
{
    Console.WriteLine($"Client Reset requested: {clientResetException.Message}");

    // Prompt user to perform a client reset immediately. If they don't,
    // they won't receive any data from the server until they restart the app
    // and all changes they make will be discarded when the app restarts.
    var didUserConfirmReset = ShowUserAConfirmationDialog();
    if (didUserConfirmReset)
    {
        // Close the Realm before doing the reset. It must be 
        // deleted as part of the reset.
        fsRealm.Dispose();

        // perform the client reset
        var didReset = clientResetException.InitiateClientReset();
        if (didReset)
        {
            // Navigate the user back to the main page or reopen the
            // the Realm and reinitialize the current page
        }
        else
        {
            // Reset failed - notify user that they'll need to
            // update the app
        }
    }
}

Test Client Reset Handling

Puede probar manualmente el manejo de restablecimiento del cliente de su aplicación finalizando y volviendo a habilitar la sincronización del dispositivo.

When you terminate and re-enable Sync, clients that have previously connected with Sync are unable to connect until after they perform a client reset. Terminating Sync deletes the metadata from the server that allows the client to synchronize. The client must download a new copy of the realm from the server. The server sends a client reset error to these clients. So, when you terminate Sync, you trigger the client reset condition.

To test client reset handling:

1. Write data from a client application and wait for it to synchronize.

2. Termina y vuelve a habilitar Device Sync.

3. Ejecuta la aplicación cliente nuevamente. La aplicación debería obtener un error de restablecimiento del cliente cuando intente conectarse al servidor.