Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Gestione dei callback degli eventi
<a name="handling-callbacks"></a>

****  
Se non hai mai usato Amazon Cognito Sync, utilizza [AWS AppSync](https://aws.amazon.com/appsync/). Come Amazon Cognito Sync, AWS AppSync è un servizio per la sincronizzazione dei dati delle applicazioni tra dispositivi.  
Consente di sincronizzare i dati dell'utente come le preferenze dell'app o lo stato del gioco. Inoltre estende queste funzionalità consentendo a più utenti di sincronizzare e collaborare in tempo reale su dati condivisi.

In qualità di sviluppatore di Amazon Cognito Sync, puoi implementare diverse callback per gestire diversi eventi e scenari di sincronizzazione. L'`SyncCallback`interfaccia di Android SDK configura le notifiche sulla sincronizzazione dei set di dati, ad esempio `onSuccess()` quando un set di dati viene scaricato correttamente, quando si verifica un'eccezione e per `onFailure()` risolvere i conflitti tra dati locali e `onConflict()` remoti.

Nell'SDK iOS, puoi registrarti per notifiche simili `AWSCognitoDidStartSynchronizeNotification` e impostare gestori come quello `AWSCognitoRecordConflictHandler` per la risoluzione dei conflitti. Le JavaScript piattaforme Unity e Xamarin hanno meccanismi di callback analoghi. Quando implementi questi callback, l'applicazione può gestire in modo corretto i vari eventi e scenari di sincronizzazione che possono verificarsi quando si utilizza Amazon Cognito Sync.

## Android
<a name="handling-callbacks-1.android"></a>

**SyncCallback Interfaccia**

Se implementi l'interfaccia `SyncCallback`, puoi ricevere notifiche sulla tua app riguardanti la sincronizzazione del set di dati. La tua app può quindi prendere decisioni attive sull'eliminazione di dati locali, sull'unione di profili autenticati e non autenticati e la risoluzione di conflitti di sincronizzazione. È consigliabile implementare i seguenti metodi, che sono richiesti dall'interfaccia:
+ `onSuccess()`
+ `onFailure()`
+ `onConflict()`
+ `onDatasetDeleted()`
+ `onDatasetsMerged()`

Nota che, se non desideri specificare tutti le callback, puoi anche utilizzare la classe `DefaultSyncCallback`, che fornisce implementazioni predefinite e vuote per ognuna di esse.

**onSuccess**

La callback `onSuccess()` viene attivata quando un set di dati è stato scaricato con successo dall'archivio di sincronizzazione.

```
@Override
public void onSuccess(Dataset dataset, List<Record> newRecords) {
}
```

**onFailure**

onFailure() viene chiamata se si verifica un'eccezione durante la sincronizzazione.

```
@Override
public void onFailure(DataStorageException dse) {
}
```

**onConflict**

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. Il metodo `onConflict()` gestisce la risoluzione dei conflitti. Se non implementi questo metodo, il client Amazon Cognito Sync utilizza per impostazione predefinita la modifica più recente.

```
@Override
public boolean onConflict(Dataset dataset, final List<SyncConflict> conflicts) {
    List<Record> resolvedRecords = new ArrayList<Record>();
    for (SyncConflict conflict : conflicts) {
        /* resolved by taking remote records */
        resolvedRecords.add(conflict.resolveWithRemoteRecord());

        /* alternately take the local records */
        // resolvedRecords.add(conflict.resolveWithLocalRecord());

        /* or customer logic, say concatenate strings */
        // String newValue = conflict.getRemoteRecord().getValue()
        //     + conflict.getLocalRecord().getValue();
        // resolvedRecords.add(conflict.resolveWithValue(newValue);
    }
    dataset.resolve(resolvedRecords);

    // return true so that synchronize() is retried after conflicts are resolved
    return true;
}
```

**onDatasetDeleted**

Quando un set di dati viene eliminato, il client Amazon Cognito usa l'interfaccia `SyncCallback` per confermare se la copia del set di dati memorizzata nella cache locale deve anch'essa essere eliminata. Implementa il metodo `onDatasetDeleted()` per comunicare all'SDK del client che cosa fare con i dati locali.

```
@Override
public boolean onDatasetDeleted(Dataset dataset, String datasetName) {
    // return true to delete the local copy of the dataset
    return true;
}
```

**onDatasetMerged**

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite il metodo `onDatasetsMerged()`:

```
@Override
public boolean onDatasetsMerged(Dataset dataset, List<String> datasetNames) {
    // return false to handle Dataset merge outside the synchronization callback
    return false;
}
```

## iOS - Objective-C
<a name="handling-callbacks-1.ios-objc"></a>

**Notifiche di sincronizzazione**

Il client Amazon Cognito durante una chiamata di sincronizzazione emetterà un numero di eventi di `NSNotification`. Puoi registrarti per monitorare queste notifiche attraverso lo standard `NSNotificationCenter`:

```
[NSNotificationCenter defaultCenter]
  addObserver:self
  selector:@selector(myNotificationHandler:)
  name:NOTIFICATION_TYPE
  object:nil];
```

Amazon Cognito supporta cinque tipi di notifica, elencati di seguito.

**AWSCognitoDidStartSynchronizeNotification**

Viene chiamato quando un'operazione di sincronizzazione è in fase di avvio. La `userInfo` conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

**AWSCognitoDidEndSynchronizeNotification**

Viene chiamato quando un'operazione di sincronizzazione viene completata (correttamente o meno). La `userInfo` conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

**AWSCognitoDidFailToSynchronizeNotification**

Viene chiamato quando un'operazione di sincronizzazione non va a buon fine. La `userInfo` conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e l'errore chiave, che conterrà l'errore che ha causato il fallimento.

**AWSCognitoDidChangeRemoteValueNotification**

Chiamato quando le modifiche locali vengono inviate correttamente ad Amazon Cognito. `userInfo`Conterrà il set di dati chiave che è il nome del set di dati da sincronizzare e le chiavi chiave che conterranno una NSArray delle chiavi di registrazione che sono state inserite.

**AWSCognitoDidChangeLocalValueFromRemoteNotification**

Viene chiamato quando un valore locale si modifica a causa di un'operazione di sincronizzazione. `userInfo`Conterrà il set di dati chiave che è il nome del set di dati da sincronizzare e le chiavi chiave che conterranno una delle chiavi di registrazione modificate. NSArray 

**Gestore della risoluzione del conflitto**

Durante un'operazione di sincronizzazione, possono sorgere dei conflitti se la stessa chiave è stata modificata nell'archivio locale e in quello di sincronizzazione. Se non hai impostato un gestore della risoluzione dei conflitti, Amazon Cognito sceglierà di default l'aggiornamento più recente.

Implementando e assegnando un AWSCognito RecordConflictHandler è possibile modificare la risoluzione predefinita dei conflitti. Il AWSCognito conflitto dei parametri di input Conflict contiene un oggetto AWSCognito Record sia per i dati memorizzati nella cache locale che per il record in conflitto nell'archivio di sincronizzazione. Utilizzando il AWSCognito Conflict è possibile risolvere il conflitto con il record locale: [conflict resolveWithLocal Record], il record remoto: [conflict resolveWithRemote Record] o un nuovo valore: [ resolveWithValueconflict:value]. Il ritorno a zero da questo metodo impedisce alla sincronizzazione di continuare e il conflitto verrà presentato ancora, la prossima volta che il processo di sincronizzazione si riavvierà.

Puoi impostare il gestore della risoluzione del conflitto al livello del client:

```
client.conflictHandler = ^AWSCognitoResolvedConflict* (NSString *datasetName, AWSCognitoConflict *conflict) {
    // always choose local changes
    return [conflict resolveWithLocalRecord];
};
```

Oppure a livello del set di dati:

```
dataset.conflictHandler = ^AWSCognitoResolvedConflict* (NSString *datasetName, AWSCognitoConflict *conflict) {
    // override and always choose remote changes
    return [conflict resolveWithRemoteRecord];
};
```

**Gestore dell'eliminazione del set di dati**

Quando un set di dati viene eliminato, il client Amazon Cognito usa `AWSCognitoDatasetDeletedHandler` per confermare se la copia del set di dati memorizzata nella cache locale deve anch'essa essere eliminata. Se non è stato implementato alcun `AWSCognitoDatasetDeletedHandler`, i dati locali saranno rimossi automaticamente. Implementa un `AWSCognitoDatasetDeletedHandler` se desideri mantenere una copia dei dati locali prima della cancellazione, o mantenere i dati locali.

Puoi impostare il gestore dell'eliminazione del set di dati a livello del client:

```
client.datasetDeletedHandler = ^BOOL (NSString *datasetName) {
    // make a backup of the data if you choose
    ...
    // delete the local data (default behavior)
    return YES;
};
```

Oppure a livello del set di dati:

```
dataset.datasetDeletedHandler = ^BOOL (NSString *datasetName) {
    // override default and keep the local data
    return NO;
};
```

**Gestore dell'unione del set di dati**

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le i vengono avvisate dell'unione tramite `DatasetMergeHandler`. Il gestore riceverà il nome del set di dati radice, nonché una vasta gamma di nomi di set di dati contrassegnati come unioni dei set di dati root.

In caso contrario, `DatasetMergeHandler` viene implementato, questi set di dati saranno ignorati ma continueranno a consumare lo spazio nei set di dati con un totale di massimo 20 identità.

Puoi impostare il gestore dell'unione del set di dati a livello del client:

```
client.datasetMergedHandler = ^(NSString *datasetName, NSArray *datasets) {
    // Blindly delete the datasets
    for (NSString *name in datasets) {
        AWSCognitoDataset *merged = [[AWSCognito defaultCognito] openOrCreateDataset:name];
       [merged clear];
       [merged synchronize];
    }
};
```

Oppure a livello del set di dati:

```
dataset.datasetMergedHandler = ^(NSString *datasetName, NSArray *datasets) {
    // Blindly delete the datasets
    for (NSString *name in datasets) {
        AWSCognitoDataset *merged = [[AWSCognito defaultCognito] openOrCreateDataset:name];
        // do something with the data if it differs from existing dataset
        ...
        // now delete it
        [merged clear];
        [merged synchronize];
    }
};
```

## iOS - Swift
<a name="handling-callbacks-1.ios-swift"></a>

**Notifiche di sincronizzazione**

Il client Amazon Cognito durante una chiamata di sincronizzazione emetterà un numero di eventi di `NSNotification`. Puoi registrarti per monitorare queste notifiche attraverso lo standard `NSNotificationCenter`:

```
NSNotificationCenter.defaultCenter().addObserver(observer: self,
   selector: "myNotificationHandler",
   name:NOTIFICATION_TYPE,
   object:nil)
```

Amazon Cognito supporta cinque tipi di notifica, elencati di seguito.

**AWSCognitoDidStartSynchronizeNotification**

Viene chiamato quando un'operazione di sincronizzazione è in fase di avvio. La `userInfo` conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

**AWSCognitoDidEndSynchronizeNotification**

Viene chiamato quando un'operazione di sincronizzazione viene completata (correttamente o meno). La `userInfo` conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato.

**AWSCognitoDidFailToSynchronizeNotification**

Viene chiamato quando un'operazione di sincronizzazione non va a buon fine. La `userInfo` conterrà il set di dati chiave, che è il nome del set di dati che viene sincronizzato, e l'errore chiave, che conterrà l'errore che ha causato il fallimento.

**AWSCognitoDidChangeRemoteValueNotification**

Chiamato quando le modifiche locali vengono inviate correttamente ad Amazon Cognito. `userInfo`Conterrà il set di dati chiave che è il nome del set di dati da sincronizzare e le chiavi chiave che conterranno una delle chiavi NSArray di registrazione che sono state inserite.

**AWSCognitoDidChangeLocalValueFromRemoteNotification**

Viene chiamato quando un valore locale si modifica a causa di un'operazione di sincronizzazione. `userInfo`Conterrà il set di dati chiave che è il nome del set di dati da sincronizzare e le chiavi chiave che conterranno una delle chiavi di registrazione modificate. NSArray 

**Gestore della risoluzione del conflitto**

Durante un'operazione di sincronizzazione, possono sorgere dei conflitti se la stessa chiave è stata modificata nell'archivio locale e in quello di sincronizzazione. Se non hai impostato un gestore della risoluzione dei conflitti, Amazon Cognito sceglierà per impostazione predefinita l'aggiornamento più recente.

Con l'implementazione e l'assegnazione di un `AWSCognitoRecordConflictHandler` puoi modificare la risoluzione dei conflitti predefiniti. Il conflitto del parametro di input `AWSCognitoConflict` contiene un oggetto `AWSCognitoRecord` sia per i dati memorizzati nella cache locale, sia per i record di conflitto nello store di sincronizzazione. Utilizzando il `AWSCognitoConflict` è possibile risolvere il conflitto con il record locale: [conflict resolveWithLocal Record], il record remoto: [conflict resolveWithRemote Record] o un nuovo valore: [conflict:value]. resolveWithValue Il ritorno a zero da questo metodo impedisce alla sincronizzazione di continuare e il conflitto verrà presentato ancora, la prossima volta che il processo di sincronizzazione si riavvierà.

Puoi impostare il gestore della risoluzione del conflitto al livello del client:

```
client.conflictHandler = {
    (datasetName: String?, conflict: AWSCognitoConflict?) -> AWSCognitoResolvedConflict? in
    return conflict.resolveWithLocalRecord()
}
```

Oppure a livello del set di dati:

```
dataset.conflictHandler = {
    (datasetName: String?, conflict: AWSCognitoConflict?) -> AWSCognitoResolvedConflict? in
    return conflict.resolveWithLocalRecord()
}
```

**Gestore dell'eliminazione del set di dati**

Quando un set di dati viene eliminato, il client Amazon Cognito usa `AWSCognitoDatasetDeletedHandler` per confermare se la copia del set di dati memorizzata nella cache locale deve anch'essa essere eliminata. Se non è stato implementato alcun `AWSCognitoDatasetDeletedHandler`, i dati locali saranno rimossi automaticamente. Implementa un `AWSCognitoDatasetDeletedHandler` se desideri mantenere una copia dei dati locali prima della cancellazione, o mantenere i dati locali.

Puoi impostare il gestore dell'eliminazione del set di dati a livello del client:

```
client.datasetDeletedHandler = {
      (datasetName: String!) -> Bool in
      // make a backup of the data if you choose
      ...
      // delete the local data (default behaviour)
      return true
}
```

Oppure a livello del set di dati:

```
dataset.datasetDeletedHandler = {
      (datasetName: String!) -> Bool in
      // make a backup of the data if you choose
      ...
      // delete the local data (default behaviour)
      return true
}
```

**Handler dell'unione dei set di dati**

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le i vengono avvisate dell'unione tramite `DatasetMergeHandler`. Il gestore riceverà il nome del set di dati radice, nonché una vasta gamma di nomi di set di dati contrassegnati come unioni dei set di dati root.

In caso contrario, `DatasetMergeHandler` viene implementato, questi set di dati saranno ignorati ma continueranno a consumare lo spazio nei set di dati con un totale di massimo 20 identità.

Puoi impostare il gestore dell'unione del set di dati a livello del client:

```
client.datasetMergedHandler = {
    (datasetName: String!, datasets: [AnyObject]!) -> Void in
    for nameObject in datasets {
        if let name = nameObject as? String {
            let merged = AWSCognito.defaultCognito().openOrCreateDataset(name)
            merged.clear()
            merged.synchronize()
        }
    }
}
```

Oppure a livello del set di dati:

```
dataset.datasetMergedHandler = {
    (datasetName: String!, datasets: [AnyObject]!) -> Void in
    for nameObject in datasets {
        if let name = nameObject as? String {
            let merged = AWSCognito.defaultCognito().openOrCreateDataset(name)
            // do something with the data if it differs from existing dataset
              ...
              // now delete it
            merged.clear()
            merged.synchronize()
        }
    }
}
```

## JavaScript
<a name="handling-callbacks-1.javascript"></a>

**Callback di sincronizzazione**

Quando esegui una sincronizzazione() su un set di dati, puoi, a tua discrezione, specificare le callback per gestire ciascuno dei seguenti stati:

```
dataset.synchronize({

   onSuccess: function(dataset, newRecords) {
      //...
   },

   onFailure: function(err) {
      //...
   },

   onConflict: function(dataset, conflicts, callback) {
      //...
   },

   onDatasetDeleted: function(dataset, datasetName, callback) {
      //...
   },

  onDatasetMerged: function(dataset, datasetNames, callback) {
      //...
  }

});
```

**onSuccess()**

La callback `onSuccess()` viene attivata quando un set di dati è stato aggiornato con successo dallo store di sincronizzazione. Se definisci una callback, la sincronizzazione riuscirà automaticamente.

```
onSuccess: function(dataset, newRecords) {
   console.log('Successfully synchronized ' + newRecords.length + ' new records.');
}
```

**onFailure()**

`onFailure()` viene chiamata se si verifica un'eccezione durante la sincronizzazione. Se non definisci una callback, la sincronizzazione fallirà automaticamente.

```
onFailure: function(err) {
   console.log('Synchronization failed.');
   console.log(err);
}
```

**onConflict()**

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. Il metodo `onConflict()` gestisce la risoluzione dei conflitti. Se non implementi questo metodo, la sincronizzazione verrà interrotta ogni volta che si verifica un conflitto.

```
onConflict: function(dataset, conflicts, callback) {

   var resolved = [];

   for (var i=0; i<conflicts.length; i++) {

      // Take remote version.
      resolved.push(conflicts[i].resolveWithRemoteRecord());

      // Or... take local version.
      // resolved.push(conflicts[i].resolveWithLocalRecord());

      // Or... use custom logic.
      // var newValue = conflicts[i].getRemoteRecord().getValue() + conflicts[i].getLocalRecord().getValue();
      // resolved.push(conflicts[i].resovleWithValue(newValue);

   }

   dataset.resolve(resolved, function() {
      return callback(true);
   });

   // Or... callback false to stop the synchronization process.
   // return callback(false);

}
```

**onDatasetDeleted()**

Quando un set di dati viene eliminato, il client Amazon Cognito usa la richiamata `onDatasetDeleted()` per decidere se anche la copia del set di dati memorizzato nella cache locale deve essere eliminata. Di default, il set di dati non verrà eliminato.

```
onDatasetDeleted: function(dataset, datasetName, callback) {

   // Return true to delete the local copy of the dataset.
   // Return false to handle deleted datasets outside the synchronization callback.

   return callback(true);

}
```

**onDatasetMerged()**

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite la chiamata `onDatasetsMerged()`.

```
onDatasetMerged: function(dataset, datasetNames, callback) {

   // Return true to continue the synchronization process.
   // Return false to handle dataset merges outside the synchronization callback.

   return callback(false);

}
```

## Unità
<a name="handling-callbacks-1.unity"></a>

Dopo che hai aperto o creato un set di dati, puoi impostare su questo diverse callback che vengono attivate quando si utilizza il metodo Synchronize. Questo è il modo per registrarvi le tue callback:

```
dataset.OnSyncSuccess += this.HandleSyncSuccess;
dataset.OnSyncFailure += this.HandleSyncFailure;
dataset.OnSyncConflict = this.HandleSyncConflict;
dataset.OnDatasetMerged = this.HandleDatasetMerged;
dataset.OnDatasetDeleted = this.HandleDatasetDeleted;
```

Nota che `SyncSuccess` e `SyncFailure` usano \$1= invece di = pertanto puoi sottoscrivervi più di una callback.

**OnSyncSuccess**

La callback `OnSyncSuccess` viene attivata quando un set di dati è stato aggiornato correttamente dal cloud. Se definisci una callback, la sincronizzazione riuscirà automaticamente.

```
private void HandleSyncSuccess(object sender, SyncSuccessEvent e)
{
    // Continue with your game flow, display the loaded data, etc.
}
```

**OnSyncFailure**

`OnSyncFailure` viene chiamata se si verifica un'eccezione durante la sincronizzazione. Se non definisci una callback, la sincronizzazione fallirà automaticamente.

```
private void HandleSyncFailure(object sender, SyncFailureEvent e)
{
    Dataset dataset = sender as Dataset;
    if (dataset.Metadata != null) {
        Debug.Log("Sync failed for dataset : " + dataset.Metadata.DatasetName);
    } else {
        Debug.Log("Sync failed");
    }
    // Handle the error
    Debug.LogException(e.Exception);
}
```

**OnSyncConflict**

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. La callback `OnSyncConflict` gestisce la risoluzione dei conflitti. Se non implementi questo metodo, la sincronizzazione verrà interrotta ogni volta che si verifica un conflitto.

```
private bool HandleSyncConflict(Dataset dataset, List < SyncConflict > conflicts)
{
  if (dataset.Metadata != null) {
    Debug.LogWarning("Sync conflict " + dataset.Metadata.DatasetName);
  } else {
    Debug.LogWarning("Sync conflict");
  }
  List < Amazon.CognitoSync.SyncManager.Record > resolvedRecords = new List < Amazon.CognitoSync.SyncManager.Record > ();
  foreach(SyncConflict conflictRecord in conflicts) {
    // SyncManager provides the following default conflict resolution methods:
    //      ResolveWithRemoteRecord - overwrites the local with remote records
    //      ResolveWithLocalRecord - overwrites the remote with local records
    //      ResolveWithValue - to implement your own logic
    resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
  }
  // resolves the conflicts in local storage
  dataset.Resolve(resolvedRecords);
  // on return true the synchronize operation continues where it left,
  //      returning false cancels the synchronize operation
  return true;
}
```

**OnDatasetDeleted**

Quando un set di dati viene eliminato, il client Amazon Cognito usa la richiamata `OnDatasetDeleted` per decidere se anche la copia del set di dati memorizzato nella cache locale deve essere eliminata. Di default, il set di dati non verrà eliminato.

```
private bool HandleDatasetDeleted(Dataset dataset)
  {
      Debug.Log(dataset.Metadata.DatasetName + " Dataset has been deleted");
      // Do clean up if necessary
      // returning true informs the corresponding dataset can be purged in the local storage and return false retains the local dataset
      return true;
  }
```

**OnDatasetMerged**

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite la chiamata `OnDatasetsMerged`.

```
public bool HandleDatasetMerged(Dataset localDataset, List<string> mergedDatasetNames)
{
    foreach (string name in mergedDatasetNames)
    {
        Dataset mergedDataset = syncManager.OpenOrCreateDataset(name);
        //Lambda function to delete the dataset after fetching it
        EventHandler<SyncSuccessEvent> lambda;
        lambda = (object sender, SyncSuccessEvent e) => {
            ICollection<string> existingValues = localDataset.GetAll().Values;
            ICollection<string> newValues = mergedDataset.GetAll().Values;

            //Implement your merge logic here

            mergedDataset.Delete(); //Delete the dataset locally
            mergedDataset.OnSyncSuccess -= lambda; //We don't want this callback to be fired again
            mergedDataset.OnSyncSuccess += (object s2, SyncSuccessEvent e2) => {
                localDataset.Synchronize(); //Continue the sync operation that was interrupted by the merge
            };
            mergedDataset.Synchronize(); //Synchronize it as deleted, failing to do so will leave us in an inconsistent state
        };
        mergedDataset.OnSyncSuccess += lambda;
        mergedDataset.Synchronize(); //Asnchronously fetch the dataset
    }

    // returning true allows the Synchronize to continue and false stops it
    return false;
}
```

## Xamarin
<a name="handling-callbacks-1.xamarin"></a>

Dopo che hai aperto o creato un set di dati, puoi impostare su questo diverse callback che vengono attivate quando si utilizza il metodo Synchronize. Questo è il modo per registrarvi le tue callback:

```
dataset.OnSyncSuccess += this.HandleSyncSuccess;
dataset.OnSyncFailure += this.HandleSyncFailure;
dataset.OnSyncConflict = this.HandleSyncConflict;
dataset.OnDatasetMerged = this.HandleDatasetMerged;
dataset.OnDatasetDeleted = this.HandleDatasetDeleted;
```

Nota che `SyncSuccess` e `SyncFailure` usano \$1= invece di = pertanto puoi sottoscrivervi più di una callback.

**OnSyncSuccess**

La callback `OnSyncSuccess` viene attivata quando un set di dati è stato aggiornato correttamente dal cloud. Se definisci una callback, la sincronizzazione riuscirà automaticamente.

```
private void HandleSyncSuccess(object sender, SyncSuccessEventArgs e)
{
    // Continue with your game flow, display the loaded data, etc.
}
```

**OnSyncFailure**

`OnSyncFailure` viene chiamata se si verifica un'eccezione durante la sincronizzazione. Se non definisci una callback, la sincronizzazione fallirà automaticamente.

```
private void HandleSyncFailure(object sender, SyncFailureEventArgs e)
{
    Dataset dataset = sender as Dataset;
    if (dataset.Metadata != null) {
        Console.WriteLine("Sync failed for dataset : " + dataset.Metadata.DatasetName);
    } else {
        Console.WriteLine("Sync failed");
    }
}
```

**OnSyncConflict**

Possono verificarsi dei conflitti se la stessa chiave è stata modificata nello store locale e in quello di sincronizzazione. La callback `OnSyncConflict` gestisce la risoluzione dei conflitti. Se non implementi questo metodo, la sincronizzazione verrà interrotta ogni volta che si verifica un conflitto.

```
private bool HandleSyncConflict(Dataset dataset, List < SyncConflict > conflicts)
{
  if (dataset.Metadata != null) {
    Console.WriteLine("Sync conflict " + dataset.Metadata.DatasetName);
  } else {
    Console.WriteLine("Sync conflict");
  }
  List < Amazon.CognitoSync.SyncManager.Record > resolvedRecords = new List < Amazon.CognitoSync.SyncManager.Record > ();
  foreach(SyncConflict conflictRecord in conflicts) {
    // SyncManager provides the following default conflict resolution methods:
    //      ResolveWithRemoteRecord - overwrites the local with remote records
    //      ResolveWithLocalRecord - overwrites the remote with local records
    //      ResolveWithValue - to implement your own logic
    resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
  }
  // resolves the conflicts in local storage
  dataset.Resolve(resolvedRecords);
  // on return true the synchronize operation continues where it left,
  //      returning false cancels the synchronize operation
  return true;
}
```

**OnDatasetDeleted**

Quando un set di dati viene eliminato, il client Amazon Cognito usa la richiamata `OnDatasetDeleted` per decidere se anche la copia del set di dati memorizzato nella cache locale deve essere eliminata. Di default, il set di dati non verrà eliminato.

```
private bool HandleDatasetDeleted(Dataset dataset)
{
    Console.WriteLine(dataset.Metadata.DatasetName + " Dataset has been deleted");
    // Do clean up if necessary
    // returning true informs the corresponding dataset can be purged in the local storage and return false retains the local dataset
    return true;
}
```

**OnDatasetMerged**

Quando due identità precedentemente scollegate vengono collegate, tutti i loro set di dati vengono uniti. Le applicazioni vengono avvisate dell'unione tramite la chiamata `OnDatasetsMerged`.

```
public bool HandleDatasetMerged(Dataset localDataset, List<string> mergedDatasetNames)
{
    foreach (string name in mergedDatasetNames)
    {
        Dataset mergedDataset = syncManager.OpenOrCreateDataset(name);

            //Implement your merge logic here

        mergedDataset.OnSyncSuccess += lambda;
        mergedDataset.SynchronizeAsync(); //Asnchronously fetch the dataset
    }

    // returning true allows the Synchronize to continue and false stops it
    return false;
}
```