डेटा बचाना

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

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

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

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

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

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

ध्यान रखें कि आपके एकता परियोजना के लिए Firebase जोड़ने दोनों में कार्य शामिल है Firebase सांत्वना और अपने खुले एकता परियोजना में (उदाहरण के लिए, आप Firebase config फ़ाइलों कंसोल से डाउनलोड, फिर उन्हें अपने एकता परियोजना में ले जाते हैं)।

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

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>

यदि आप एक टाइप किया सी # वस्तु का उपयोग करते हैं, तो आप में बनाया का उपयोग कर सकते 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;
    }
}

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

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

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

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

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

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

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

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

अगला कदम