לשמור מידע

לפני שאתה מתחיל

לפני שתוכל להשתמש מסד זמן אמת , עליך:

  • רשום את פרויקט Unity והגדר אותו לשימוש ב- Firebase.

    • אם פרויקט Unity שלך כבר משתמש ב- Firebase, הוא כבר רשום ומוגדר עבור Firebase.

    • אם אין לך פרויקט אחדות, אתה יכול להוריד אפליקציה לדוגמא .

  • מוסיפים את SDK האחדות Firebase (במיוחד, FirebaseDatabase.unitypackage ) לפרויקט האחדות שלך.

שים לב כי הוספת Firebase לפרויקט האחדות שלך כרוך משימות הן Firebase הקונסולה ו בפרויקט האחדות פתוח (למשל, אתה מוריד קבצי config Firebase מהמסוף, ולאחר מכן להעביר אותם לתוך פרויקט האחדות שלכם).

שמירת נתונים

ישנן חמש שיטות לכתיבת נתונים למאגר הנתונים בזמן אמת של Firebase:

שיטה שימושים נפוצים
SetValueAsync() כתוב או להחליף נתונים נתיב מוגדר, כגון users/<user-id>/<username> .
SetRawJsonValueAsync() כתוב או להחליף נתונים עם גלם JSON, כגון users/<user-id>/<username> .
Push() הוסף לרשימת נתונים. בכל פעם שאתם קוראים Push() , Firebase מייצר מפתח ייחודי שיכול לשמש גם מזהה ייחודי, כגון user-scores/<user-id>/<unique-score-id> .
UpdateChildrenAsync() עדכן חלק מהמפתחות לנתיב מוגדר מבלי להחליף את כל הנתונים.
RunTransaction() עדכן נתונים מורכבים שעלולים להיפגם על ידי עדכונים במקביל.

קבל מידע על נתונים

כדי לכתוב נתונים למסד הנתונים, אתה צריך מופע של 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;
  }
}

כתוב, עדכן או מחק נתונים בהתייחסות

פעולות כתיבה בסיסיות

עבור פעולות כתיבה בסיסיות, אתה יכול להשתמש SetValueAsync() כדי לשמור את נתון הפניה שצוינה, החלפה כול נתון קיימים על השביל. תוכל להשתמש בשיטה זו כדי להעביר סוגים התואמים את סוגי JSON הזמינים כדלקמן:

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

אם אתה משתמש אובייקט # C מוקלד, אתה יכול להשתמש מובנה JsonUtility.ToJson() כדי להמיר את האובייקט כדי גלם JSON ולקרוא SetRawJsonValueAsync() . לדוגמה, ייתכן שיש לך מחלקת משתמשים שנראתה כך:

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

    public User() {
    }

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

אתה יכול להוסיף משתמש עם SetRawJsonValueAsync() כדלקמן:

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);
}

שימוש SetValueAsync() או SetRawJsonValueAsync() בדרך זו נתונים מחליף במיקום שצוין, לרבות כל הצמתים הילד. עם זאת, אתה עדיין יכול לעדכן ילד מבלי לשכתב את כל האובייקט. אם אתה רוצה לאפשר למשתמשים לעדכן את הפרופילים שלהם תוכל לעדכן את שם המשתמש באופן הבא:

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

הוסף לרשימת נתונים

השתמש Push() השיטה לצרף נתונים לרשימה ביישומים מרובים משתמשים. Push() שיטה מייצר מפתח ייחודי בכל פעם ילד חדש מתווסף התייחסות Firebase שצוין. על ידי שימוש במפתחות אלה שנוצרו אוטומטית עבור כל רכיב חדש ברשימה, מספר לקוחות יכולים להוסיף ילדים לאותו מיקום בו זמנית ללא התנגשויות כתיבה. המפתח הייחודי שנוצר על ידי Push() מבוסס על חותמת, כך פריטי רשימה מסודרים באופן אוטומטי לפי סדר כרונולוגי.

אתה יכול להשתמש התייחסות לנתונים החדשים שהוחזרו על ידי Push() השיטה כדי לקבל את הערך של נתון מפתח שנוצר באופן אוטומטי או סט של הילדים לילד. שיחות Key על Push() הפניה מחזירה את הערך של המפתח שנוצר באופן אוטומטי.

עדכן שדות ספציפיים

כדי לכתוב בו זמנית לילדים ספציפיים של צומת מבלי להחליף צומת ילד אחרים, להשתמש UpdateChildrenAsync() השיטה.

בעת התקשרות UpdateChildrenAsync() , אתה יכול לעדכן ערכי ילד ברמה נמוכה יותר על ידי ציון נתיב עבור המפתח. אם הנתונים מאוחסנים במקומות מרובים סולם טוב יותר, אתה יכול לעדכן את כל המופעים של נתונים באמצעות מאוורר-אאוט נתונים . לדוגמה, משחק יכול להיות LeaderboardEntry בכיתה ככה:

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;
    }
}

כדי ליצור LeaderboardEntry ובמקביל לעדכן אותו להזנת הניקוד האחרונה ולרשימת הציונים של המשתמש עצמו, המשחק משתמש בקוד כזה:

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);
}

שימושים דוגמה זו Push() כדי ליצור רשומה הצומת המכיל ערכים עבור כל המשתמשים /scores/$key ובמקביל לאחזר את המפתח עם Key . המפתח לאחר מכן ניתן להשתמש כדי ליצור ערך שני הציוני של המשתמש על /user-scores/$userid/$key .

באמצעות נתיבים אלה, אתה יכול לבצע עדכונים סימולטני ליעדים רבים בעץ JSON עם שיחה אחת כדי UpdateChildrenAsync() , כגון איך בדוגמה זו יוצרת את הרשומה החדשה בשני המקומות. עדכונים סימולטניים שנעשו בצורה זו הם אטומיים: או שכל העדכונים מצליחים או שכל העדכונים נכשלים.

מחק נתונים

הדרך הפשוטה ביותר נתונים המחיקה היא להתקשר RemoveValue() על הפניה למיקום של הנתונים.

אתה גם יכול למחוק ידי ציון null כערך לעוד פעולת הכתיבה כגון SetValueAsync() או UpdateChildrenAsync() . אתה יכול להשתמש בטכניקה זו עם UpdateChildrenAsync() כדי למחוק ילדים מרובים בשיחת API יחידה.

דע מתי הנתונים שלך מחויבים.

כדי לדעת מתי הנתונים שלך מחויבים לשרת מסד הנתונים של Firebase Realtime, תוכל להוסיף המשך. שניהם SetValueAsync() ו UpdateChildrenAsync() להחזיר Task המאפשר לך לדעת מתי הפעולה תושלם. אם השיחה לא יצליח מסיבה כלשהי, המשימות IsFaulted תהיינה נכונות עם Exception הרכוש המציין מדוע אירעה התקלה.

שמור נתונים כעסקאות

כאשר עובד עם נתונים שעלולים להיות פגום על ידי שינויים מקבילים, כגון מונים מצטברים, אתה יכול להשתמש במבצע עסקה . אתה נותן על הפעולה הזאת Func . עדכון זה Func לוקח את המצב הנוכחי של נתון כטיעון ומחזיר את המדינה החדשה רצוי שאתה רוצה לכתוב. אם לקוח אחר כותב למיקום לפני הערך החדש שלך נכתב בהצלחה, פונקציית העדכון שלך נקראת שוב עם הערך הנוכחי החדש, והכתיבה ננסה שוב.

לדוגמה, במשחק אתה יכול לאפשר למשתמשים לעדכן לוח מדדים עם חמשת הציונים הגבוהים ביותר:

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);
    });
}

שימוש בעסקה מונע מהטעות בלוח המנהלים אם משתמשים רבים רושמים ציונים בו זמנית או שללקוח היו נתונים מיושנים. אם העסקה נדחית, השרת מחזיר ללקוח את הערך הנוכחי, שמריץ את העסקה שוב עם הערך המעודכן. זה חוזר עד שהעסקה מתקבלת או שבוצעו יותר מדי ניסיונות.

כתוב נתונים במצב לא מקוון

אם לקוח מאבד את חיבור הרשת שלו, האפליקציה שלך תמשיך לפעול כראוי.

כל לקוח המחובר למסד נתונים של Firebase שומר על גרסה פנימית משלו של כל נתונים פעילים. כאשר נכתבים נתונים, הם נכתבים תחילה לגרסה המקומית הזו. לאחר מכן הלקוח של Firebase מסנכרן את הנתונים עם שרתי מסדי הנתונים המרוחקים ועם לקוחות אחרים על בסיס "המאמץ הטוב ביותר".

כתוצאה מכך, כל הכתיבות למאגר הנתונים מפעילות אירועים מקומיים באופן מיידי, לפני שנכתבים נתונים כלשהם לשרת. המשמעות היא שהאפליקציה שלך נשארת רספונסיבית ללא קשר לחביון או קישוריות ברשת.

לאחר חיבור מחדש לקישוריות, האפליקציה שלך מקבלת את סדרת האירועים המתאימה כך שהלקוח יסתנכרן עם מצב השרת הנוכחי, מבלי לכתוב קוד מותאם אישית כלשהו.

הצעדים הבאים