डेटा बचाना

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

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

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

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

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

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

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

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

Firebase रीयलटाइम डेटाबेस में डेटा लिखने के पांच तरीके हैं:

तरीका सामान्य उपयोग
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>

यदि आप एक टाइप की गई सी # ऑब्जेक्ट का उपयोग करते हैं, तो आप ऑब्जेक्ट को कच्चे जेसन में कनवर्ट करने के लिए अंतर्निहित JsonUtility.ToJson() का उपयोग कर सकते हैं और SetRawJsonValueAsync( 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 पर किया जा सकता है।

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

डेटा हटाएं

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

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

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

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

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

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

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

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

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

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

अगले कदम