Google 致力于为黑人社区推动种族平等。查看具体举措

Enregistrer des données

Avant que tu commences

Avant de pouvoir utiliser la base de données en temps réel , vous devez:

  • Enregistrez votre projet Unity et configurez-le pour utiliser Firebase.

    • Si votre projet Unity utilise déjà Firebase, il est déjà enregistré et configuré pour Firebase.

    • Si vous ne disposez pas d' un projet Unity, vous pouvez télécharger une application de l' échantillon .

  • Ajouter l' unité Firebase SDK (spécifiquement, FirebaseDatabase.unitypackage ) à votre projet Unity.

Notez que l' ajout Firebase à votre projet Unity implique des tâches à la fois dans la console Firebase et dans votre projet open unité (par exemple, vous téléchargez des fichiers de configuration Firebase de la console, puis de les déplacer dans votre projet Unity).

La sauvegarde des données

Il existe cinq méthodes pour écrire des données dans la base de données en temps réel Firebase :

Méthode Utilisations courantes
SetValueAsync() Ecrire ou remplacer les données à un chemin défini, comme les users/<user-id>/<username> d' users/<user-id>/<username> .
SetRawJsonValueAsync() Écrire ou remplacer les données JSON brutes, telles que les users/<user-id>/<username> d' users/<user-id>/<username> .
Push() Ajouter à une liste de données. Chaque fois que vous appelez Push() , Firebase génère une clé unique qui peut également être utilisé comme identifiant unique, tel que l' user-scores/<user-id>/<unique-score-id> .
UpdateChildrenAsync() Mettez à jour certaines des clés pour un chemin défini sans remplacer toutes les données.
RunTransaction() Mettez à jour les données complexes qui pourraient être corrompues par des mises à jour simultanées.

Obtenir une référence de base de données

Pour les données d'écriture à la base de données, vous avez besoin d' une instance de DatabaseReference :

using Firebase;
using Firebase.Database;

public class MyScript: MonoBehaviour {
  void Start() {
    // Get the root reference location of the database.
    DatabaseReference reference = FirebaseDatabase.DefaultInstance.RootReference;
  }
}

Écrire, mettre à jour ou supprimer des données à une référence

Opérations d'écriture de base

Pour les opérations d'écriture de base, vous pouvez utiliser SetValueAsync() pour enregistrer les données à une référence spécifiée, de remplacer toutes les données existantes sur ce chemin. Vous pouvez utiliser cette méthode pour transmettre les types qui correspondent aux types JSON disponibles comme suit :

  • string
  • long
  • double
  • bool
  • Dictionary<string, Object>
  • List<Object>

Si vous utilisez un objet C # dactylographié, vous pouvez utiliser le construit en JsonUtility.ToJson() pour convertir l'objet JSON brut et appeler SetRawJsonValueAsync() . Par exemple, vous pouvez avoir une classe User qui ressemble à ceci :

public class User {
    public string username;
    public string email;

    public User() {
    }

    public User(string username, string email) {
        this.username = username;
        this.email = email;
    }
}

Vous pouvez ajouter un utilisateur avec SetRawJsonValueAsync() comme suit:

private void writeNewUser(string userId, string name, string email) {
    User user = new User(name, email);
    string json = JsonUtility.ToJson(user);

    mDatabaseRef.Child("users").Child(userId).SetRawJsonValueAsync(json);
}

En utilisant SetValueAsync() ou SetRawJsonValueAsync() de cette manière écrasera les données à l'emplacement spécifié, y compris les nœuds enfants. Cependant, vous pouvez toujours mettre à jour un enfant sans réécrire l'intégralité de l'objet. Si vous souhaitez autoriser les utilisateurs à mettre à jour leurs profils, vous pouvez mettre à jour le nom d'utilisateur comme suit :

mDatabaseRef.Child("users").Child(userId).Child("username").SetValueAsync(name);

Ajouter à une liste de données

Utiliser le Push() Procédé pour ajouter des données à une liste dans les applications multi - utilisateur. Le Push() méthode génère une clé unique à chaque fois qu'un nouvel enfant est ajouté à la référence Firebase spécifiée. En utilisant ces clés générées automatiquement pour chaque nouvel élément de la liste, plusieurs clients peuvent ajouter des enfants au même emplacement en même temps sans conflits d'écriture. La clé unique générée par Push() est basée sur un horodatage, de sorte que les éléments de la liste sont automatiquement classés par ordre chronologique.

Vous pouvez utiliser la référence aux nouvelles données renvoyées par le Push() méthode pour obtenir la valeur de la clé de l' enfant ou généré automatiquement les données du jeu pour l'enfant. Appel Key sur un Push() référence renvoie la valeur de la clé générée automatiquement.

Mettre à jour des champs spécifiques

Pour écrire simultanément aux enfants spécifiques d'un noeud sans écraser les autres nœuds enfants, utilisez la UpdateChildrenAsync() méthode.

Lors de l' appel UpdateChildrenAsync() , vous pouvez mettre à jour les valeurs des enfants de niveau inférieur en spécifiant un chemin pour la clé. Si les données sont stockées dans plusieurs endroits à l' échelle mieux, vous pouvez mettre à jour toutes les instances de ces données à l' aide de données sortance . Par exemple, un jeu peut avoir une LeaderboardEntry classe comme ceci:

public class LeaderboardEntry {
    public string uid;
    public int score = 0;

    public LeaderboardEntry() {
    }

    public LeaderboardEntry(string uid, int score) {
        this.uid = uid;
        this.score = score;
    }

    public Dictionary<string, Object> ToDictionary() {
        Dictionary<string, Object> result = new Dictionary<string, Object>();
        result["uid"] = uid;
        result["score"] = score;

        return result;
    }
}

Pour créer un LeaderboardEntry et le mettre à jour simultanément avec le flux de score récent et la propre liste de score de l'utilisateur, le jeu utilise un code comme celui-ci :

private void WriteNewScore(string userId, int score) {
    // Create new entry at /user-scores/$userid/$scoreid and at
    // /leaderboard/$scoreid simultaneously
    string key = mDatabase.Child("scores").Push().Key;
    LeaderBoardEntry entry = new LeaderBoardEntry(userId, score);
    Dictionary<string, Object> entryValues = entry.ToDictionary();

    Dictionary<string, Object> childUpdates = new Dictionary<string, Object>();
    childUpdates["/scores/" + key] = entryValues;
    childUpdates["/user-scores/" + userId + "/" + key] = entryValues;

    mDatabase.UpdateChildrenAsync(childUpdates);
}

Cet exemple utilise Push() pour créer une entrée dans le nœud contenant des entrées pour tous les utilisateurs à /scores/$key et récupérer en même temps la clé avec la Key . La clé peut être utilisée pour créer une deuxième entrée dans les scores à l'utilisateur /user-scores/$userid/$key .

L' utilisation de ces chemins, vous pouvez effectuer des mises à jour simultanées à plusieurs endroits dans l'arborescence JSON avec un seul appel à UpdateChildrenAsync() , comme la façon dont cet exemple crée la nouvelle entrée dans les deux endroits. Les mises à jour simultanées effectuées de cette manière sont atomiques : soit toutes les mises à jour réussissent, soit toutes les mises à jour échouent.

Suprimmer les données

La façon la plus simple de suppression de données est d'appeler RemoveValue() sur une référence à l'emplacement de ces données.

Vous pouvez également supprimer en spécifiant null comme valeur pour une autre opération d'écriture tels que SetValueAsync() ou UpdateChildrenAsync() . Vous pouvez utiliser cette technique avec UpdateChildrenAsync() pour supprimer plusieurs enfants dans un seul appel API.

Sachez quand vos données sont validées.

Pour savoir quand vos données sont validées sur le serveur Firebase Realtime Database, vous pouvez ajouter une continuation. Les deux SetValueAsync() et UpdateChildrenAsync() retourne une des Task qui vous permet de savoir quand l'opération est terminée. Si l'appel échoue pour une raison quelconque, les tâches IsFaulted seront vrai avec l' Exception des biens indiquant pourquoi l'échec.

Enregistrer les données en tant que transactions

Lorsque vous travaillez avec des données qui pourraient être corrompues par des modifications simultanées telles que les compteurs supplémentaires, vous pouvez utiliser une opération de transaction . Vous donnez cette opération un Func . Cette mise à jour Func prend l'état actuel des données comme argument et retourne le nouvel état désiré que vous souhaitez écrire. Si un autre client écrit à l'emplacement avant que votre nouvelle valeur ne soit écrite avec succès, votre fonction de mise à jour est à nouveau appelée avec la nouvelle valeur actuelle et l'écriture est retentée.

Par exemple, dans un jeu, vous pouvez autoriser les utilisateurs à mettre à jour un classement avec les cinq meilleurs scores :

private void AddScoreToLeaders(string email, 
                               long score,
                               DatabaseReference leaderBoardRef) {

    leaderBoardRef.RunTransaction(mutableData => {
      List<object> leaders = mutableData.Value as List<object>

      if (leaders == null) {
        leaders = new List<object>();
      } else if (mutableData.ChildrenCount >= MaxScores) {
        long minScore = long.MaxValue;
        object minVal = null;
        foreach (var child in leaders) {
          if (!(child is Dictionary<string, object>)) continue;
          long childScore = (long)
                      ((Dictionary<string, object>)child)["score"];
          if (childScore < minScore) {
            minScore = childScore;
            minVal = child;
          }
        }
        if (minScore > score) {
          // The new score is lower than the existing 5 scores, abort.
          return TransactionResult.Abort();
        }

        // Remove the lowest score.
        leaders.Remove(minVal);
      }

      // Add the new high score.
      Dictionary<string, object> newScoreMap =
                       new Dictionary<string, object>();
      newScoreMap["score"] = score;
      newScoreMap["email"] = email;
      leaders.Add(newScoreMap);
      mutableData.Value = leaders;
      return TransactionResult.Success(mutableData);
    });
}

L'utilisation d'une transaction empêche le classement d'être incorrect si plusieurs utilisateurs enregistrent des scores en même temps ou si le client avait des données périmées. Si la transaction est rejetée, le serveur renvoie la valeur actuelle au client, qui exécute à nouveau la transaction avec la valeur mise à jour. Cela se répète jusqu'à ce que la transaction soit acceptée ou que trop de tentatives aient été effectuées.

Écrire des données hors ligne

Si un client perd sa connexion réseau, votre application continuera à fonctionner correctement.

Chaque client connecté à une base de données Firebase conserve sa propre version interne de toutes les données actives. Lorsque les données sont écrites, elles sont d'abord écrites dans cette version locale. Le client Firebase synchronise ensuite ces données avec les serveurs de base de données distants et avec d'autres clients au mieux.

Par conséquent, toutes les écritures dans la base de données déclenchent des événements locaux immédiatement, avant que des données ne soient écrites sur le serveur. Cela signifie que votre application reste réactive quelle que soit la latence ou la connectivité du réseau.

Une fois la connectivité rétablie, votre application reçoit l'ensemble d'événements approprié afin que le client se synchronise avec l'état actuel du serveur, sans avoir à écrire de code personnalisé.

Prochaines étapes