डेटा बचाना

शुरू करने से पहले

इससे पहले कि आप रीयलटाइम डेटाबेस का उपयोग कर सकें, आपको यह करना होगा:

• अपना यूनिटी प्रोजेक्ट पंजीकृत करें और इसे फायरबेस का उपयोग करने के लिए कॉन्फ़िगर करें।

  • यदि आपका यूनिटी प्रोजेक्ट पहले से ही फायरबेस का उपयोग करता है, तो यह पहले से ही फायरबेस के लिए पंजीकृत और कॉन्फ़िगर किया गया है।

  • यदि आपके पास यूनिटी प्रोजेक्ट नहीं है, तो आप एक नमूना ऐप डाउनलोड कर सकते हैं।

• अपने यूनिटी प्रोजेक्ट में फायरबेस यूनिटी एसडीके (विशेष रूप से, FirebaseDatabase.unitypackage ) जोड़ें।

ध्यान दें कि आपके यूनिटी प्रोजेक्ट में फायरबेस जोड़ने से फायरबेस कंसोल और आपके ओपन यूनिटी प्रोजेक्ट दोनों में कार्य शामिल होते हैं (उदाहरण के लिए, आप कंसोल से फायरबेस कॉन्फिग फाइल डाउनलोड करते हैं, फिर उन्हें अपने यूनिटी प्रोजेक्ट में ले जाते हैं)।

डेटा सहेजा जा रहा है

फ़ायरबेस रीयलटाइम डेटाबेस में डेटा लिखने की पाँच विधियाँ हैं:

तरीका	सामान्य उपयोग
SetValueAsync()	डेटा को किसी परिभाषित पथ पर लिखें या बदलें, जैसे कि users/<user-id>/<username> ।
SetRawJsonValueAsync()	डेटा को कच्चे Json से लिखें या बदलें, जैसे कि users/<user-id>/<username> ।
Push()	डेटा की सूची में जोड़ें. हर बार जब आप Push() को कॉल करते हैं, तो फायरबेस एक अद्वितीय कुंजी उत्पन्न करता है जिसका उपयोग एक अद्वितीय पहचानकर्ता के रूप में भी किया जा सकता है, जैसे कि 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# ऑब्जेक्ट का उपयोग करते हैं, तो आप ऑब्जेक्ट को कच्चे Json में बदलने के लिए अंतर्निहित JsonUtility.ToJson() का उपयोग कर सकते हैं और 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() विधि एक अद्वितीय कुंजी उत्पन्न करती है। सूची में प्रत्येक नए तत्व के लिए इन ऑटो-जेनरेट की गई कुंजियों का उपयोग करके, कई ग्राहक बिना लेखन विरोध के एक ही समय में बच्चों को एक ही स्थान पर जोड़ सकते हैं। Push() द्वारा उत्पन्न अद्वितीय कुंजी टाइमस्टैम्प पर आधारित होती है, इसलिए सूची आइटम स्वचालित रूप से कालानुक्रमिक रूप से क्रमबद्ध होते हैं।

आप बच्चे की स्वत: जेनरेट की गई कुंजी का मूल्य प्राप्त करने या बच्चे के लिए सेट डेटा प्राप्त करने के लिए Push() विधि द्वारा लौटाए गए नए डेटा के संदर्भ का उपयोग कर सकते हैं। Push() संदर्भ पर Key कॉल करने से स्वतः उत्पन्न कुंजी का मान वापस आ जाता है।

विशिष्ट फ़ील्ड अपडेट करें

अन्य चाइल्ड नोड्स को अधिलेखित किए बिना एक नोड के विशिष्ट बच्चों को एक साथ लिखने के लिए, 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;
    }
}

लीडरबोर्डएंट्री बनाने और साथ ही इसे हाल के स्कोर फ़ीड और उपयोगकर्ता की स्वयं की स्कोर सूची में अपडेट करने के लिए, गेम इस तरह कोड का उपयोग करता है:

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

यह उदाहरण /scores/$key पर सभी उपयोगकर्ताओं के लिए प्रविष्टियों वाले नोड में एक प्रविष्टि बनाने के लिए Push() का उपयोग करता है और साथ ही Key के साथ कुंजी को पुनः प्राप्त करता है। कुंजी का उपयोग /user-scores/$userid/$key पर उपयोगकर्ता के स्कोर में दूसरी प्रविष्टि बनाने के लिए किया जा सकता है।

इन पथों का उपयोग करके, आप UpdateChildrenAsync() पर एक कॉल के साथ JSON ट्री में कई स्थानों पर एक साथ अपडेट कर सकते हैं, जैसे कि यह उदाहरण दोनों स्थानों में नई प्रविष्टि कैसे बनाता है। इस तरह से किए गए एक साथ किए गए अपडेट परमाणु होते हैं: या तो सभी अपडेट सफल होते हैं या सभी अपडेट विफल हो जाते हैं।

डेटा हटाएँ

डेटा को हटाने का सबसे सरल तरीका उस डेटा के स्थान के संदर्भ में RemoveValue() कॉल करना है।

आप SetValueAsync() या UpdateChildrenAsync() जैसे किसी अन्य लेखन ऑपरेशन के लिए मान के रूप में null निर्दिष्ट करके भी हटा सकते हैं। आप एक ही एपीआई कॉल में एकाधिक बच्चों को हटाने के लिए इस तकनीक का उपयोग UpdateChildrenAsync() के साथ कर सकते हैं।

जानें कि आपका डेटा कब प्रतिबद्ध है।

यह जानने के लिए कि आपका डेटा फ़ायरबेस रीयलटाइम डेटाबेस सर्वर के लिए कब प्रतिबद्ध है, आप एक निरंतरता जोड़ सकते हैं। 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);
    });
}

यदि कई उपयोगकर्ता एक ही समय में स्कोर रिकॉर्ड करते हैं या क्लाइंट के पास पुराना डेटा है तो लेनदेन का उपयोग करने से लीडरबोर्ड गलत होने से बच जाता है। यदि लेनदेन अस्वीकार कर दिया जाता है, तो सर्वर क्लाइंट को वर्तमान मूल्य लौटाता है, जो अद्यतन मूल्य के साथ लेनदेन को फिर से चलाता है। यह तब तक दोहराया जाता है जब तक कि लेनदेन स्वीकार नहीं हो जाता या बहुत अधिक प्रयास नहीं किए जाते।

डेटा ऑफ़लाइन लिखें

यदि कोई क्लाइंट अपना नेटवर्क कनेक्शन खो देता है, तो आपका ऐप सही ढंग से काम करता रहेगा।

फायरबेस डेटाबेस से जुड़ा प्रत्येक क्लाइंट किसी भी सक्रिय डेटा का अपना आंतरिक संस्करण रखता है। जब डेटा लिखा जाता है, तो उसे पहले इस स्थानीय संस्करण में लिखा जाता है। फ़ायरबेस क्लाइंट तब उस डेटा को दूरस्थ डेटाबेस सर्वर और अन्य क्लाइंट के साथ "सर्वोत्तम प्रयास" के आधार पर सिंक्रनाइज़ करता है।

परिणामस्वरूप, सर्वर पर कोई भी डेटा लिखे जाने से पहले, डेटाबेस पर लिखी जाने वाली सभी चीज़ें तुरंत स्थानीय घटनाओं को ट्रिगर करती हैं। इसका मतलब है कि आपका ऐप नेटवर्क विलंबता या कनेक्टिविटी की परवाह किए बिना प्रतिक्रियाशील बना रहता है।

एक बार कनेक्टिविटी पुनः स्थापित हो जाने पर, आपके ऐप को ईवेंट का उचित सेट प्राप्त होता है ताकि क्लाइंट बिना कोई कस्टम कोड लिखे वर्तमान सर्वर स्थिति के साथ समन्वयित हो सके।

अगले कदम

• अपने रीयलटाइम डेटाबेस से डेटा पुनर्प्राप्त करें
• डेटा की संरचना करना सीखें