Avant de commencer
Avant de pouvoir utiliser Realtime Database, 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 n'avez pas de projet Unity, vous pouvez télécharger un application exemple.
Ajoutez le SDK Unity Firebase (plus précisément,
FirebaseDatabase.unitypackage
) pour votre projet Unity.
Notez que l'ajout de Firebase à votre projet Unity implique des tâches dans le Console Firebase et dans votre projet Unity ouvert Par exemple, vous téléchargez les fichiers de configuration Firebase depuis la console, puis vous déplacez dans votre projet Unity).
Enregistrement des données
Il existe cinq méthodes pour écrire des données dans Firebase Realtime Database :
Méthode | Utilisations courantes |
---|---|
SetValueAsync() |
Écrivez ou remplacez des données dans un chemin défini, tel que users/<user-id>/<username> . |
SetRawJsonValueAsync() |
Écrire ou remplacer des données par des fichiers JSON bruts, tels que
users/<user-id>/<username> |
Push() |
Ajoutez des données à une liste. Chaque fois que vous appelez Push() , Firebase génère une clé unique qui peut également être utilisée comme identifiant unique, comme user-scores/<user-id>/<unique-score-id> . |
UpdateChildrenAsync() |
Mettez à jour certaines des clés d'un chemin d'accès défini sans remplacer toutes les les données. |
RunTransaction() |
Mettez à jour des données complexes qui pourraient être corrompues par des mises à jour simultanées. |
Obtenir une référence de base de données
Pour écrire des données dans 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 sur une référence
Opérations d'écriture de base
Pour les opérations d'écriture de base, vous pouvez utiliser SetValueAsync()
pour enregistrer des données dans un
spécifiée, en remplaçant toutes les données existantes de ce chemin d'accès. Vous pouvez utiliser cette
pour transmettre des types correspondant aux types JSON disponibles, comme suit:
string
long
double
bool
Dictionary<string, Object>
List<Object>
Si vous utilisez un objet C# saisi, vous pouvez utiliser la classe JsonUtility.ToJson()
intégrée
pour convertir l'objet en JSON brut et appeler SetRawJsonValueAsync()
.
Par exemple, vous pourriez avoir une classe User ressemblant à 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); }
Utiliser SetValueAsync()
ou SetRawJsonValueAsync()
de cette manière écrase 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'objet entier. Si vous souhaitez autoriser les utilisateurs
pour mettre à jour leur profil, 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
Utilisez la méthode Push()
pour ajouter des données à une liste dans des applications multi-utilisateurs.
La méthode Push()
génère une clé unique à chaque nouvelle requête
enfant est ajouté à la référence Firebase spécifiée. En utilisant ces
générées automatiquement pour chaque nouvel élément de la liste, plusieurs clients peuvent
ajouter des enfants au même emplacement et en même temps sans conflits d'écriture. La
une clé unique générée par Push()
est basée sur un code temporel. Par conséquent, les éléments de liste sont
dans un ordre chronologique
automatiquement.
Vous pouvez utiliser la référence aux nouvelles données renvoyées par la méthode Push()
pour obtenir
la valeur de la clé générée automatiquement ou
définir des données pour l'enfant. Appel en cours
Key
sur une référence Push()
renvoie la valeur de la
générée automatiquement.
Mettre à jour des champs spécifiques
Pour écrire simultanément sur des enfants spécifiques d'un nœud sans écraser d'autres
les nœuds enfants, utilisez la méthode UpdateChildrenAsync()
.
Lorsque vous appelez UpdateChildrenAsync()
, vous pouvez mettre à jour les valeurs enfants de niveau inférieur en
spécifiant un chemin d'accès pour la clé. Si les données sont stockées dans plusieurs emplacements
vous pouvez mettre à jour toutes les instances de ces données
distribution ramifiée des données. Par exemple, un jeu peut avoir une classe LeaderboardEntry
comme suit :
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 objet LeaderboardEntry et le mettre à jour simultanément avec le score récent et la liste des scores de l'utilisateur, le jeu utilise un code semblable à 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 de /scores/$key
et récupèrent simultanément la clé avec
Key
La clé peut ensuite être utilisée pour créer une deuxième entrée dans le
marque à /user-scores/$userid/$key
.
Ces chemins d'accès vous permettent d'effectuer des mises à jour simultanées de plusieurs emplacements dans
l'arborescence JSON avec un seul appel à UpdateChildrenAsync()
, comme dans cet exemple :
crée l'entrée aux deux emplacements. Des mises à jour simultanées
sont atomiques: toutes les mises à jour réussissent ou échouent.
Supprimer des données
Le moyen le plus simple de supprimer des données consiste à 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 écriture
opération, telle que SetValueAsync()
ou UpdateChildrenAsync()
. Vous pouvez utiliser cette
avec UpdateChildrenAsync()
pour supprimer plusieurs enfants dans une seule 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
vous pouvez ajouter une continuation. SetValueAsync()
et UpdateChildrenAsync()
renvoyer un Task
qui vous permet de savoir quand l'opération est terminée. Si le
l'appel échoue pour une raison quelconque, le IsFaulted
Tasks aura la valeur "true" avec
Propriété Exception
indiquant la raison de l'échec.
Enregistrer les données en tant que transactions
lorsque vous travaillez avec des données susceptibles d'être corrompues par des
modifications, telles que des compteurs incrémentiels, vous pouvez utiliser un
opération de transaction.
Attribuez un Func
à cette opération. Cette mise à jour Func
utilise l'état actuel
des données en tant qu'argument et renvoie le nouvel état souhaité
l'écriture. Si un autre client écrit à l'emplacement avant que votre nouvelle valeur ne soit
écrite avec succès, votre fonction de mise à jour est rappelée avec la nouvelle valeur
et une nouvelle tentative d'écriture est effectuée.
Par exemple, dans un jeu, vous pouvez autoriser les utilisateurs à mettre à jour un classement avec les cinq notes les plus élevées:
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 dispose de données obsolètes. Si le transaction est rejetée, le serveur renvoie la valeur actuelle au client, qui exécute à nouveau la transaction avec la valeur mise à jour. Cette opération se répète jusqu'à transaction est acceptée ou un trop grand nombre de tentatives a été effectuées.
Écrire des données hors connexion
Si un client perd sa connexion réseau, votre application continuera de fonctionner correctement.
Chaque client connecté à une base de données Firebase gère sa propre version interne de toutes les données actives. Lorsque les données sont écrites, elles sont écrites dans cette version locale en premier. Le client Firebase synchronise ensuite ces données avec la base de données distante. serveurs et avec d'autres clients, de la manière à la base.
Par conséquent, toutes les écritures dans la base de données déclenchent immédiatement des événements locaux, avant toutes les données sont é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 approprié de afin que le client se synchronise avec l'état actuel du serveur, sans avoir à et écrire n'importe quel code personnalisé.