ravendbशुरुआत रविन्दब से हुई


टिप्पणियों

यह खंड उस अवलोकन को प्रदान करता है जो रैवेंडब है, और क्यों एक डेवलपर इसका उपयोग करना चाहता है।

इसमें रैवेंडब के भीतर किसी भी बड़े विषयों का उल्लेख होना चाहिए, और संबंधित विषयों के लिए लिंक करना चाहिए। चूंकि रैवेंडब के लिए दस्तावेज़ीकरण नया है, इसलिए आपको उन संबंधित विषयों के प्रारंभिक संस्करण बनाने की आवश्यकता हो सकती है।

निःशुल्क एक साधारण रेवेनबेड कंसोल एप्लिकेशन

इस उदाहरण के लिए हम लाइव टेस्ट रैवेनडीबी उदाहरण का उपयोग करेंगे।

हम यहां एक साधारण कंसोल ऐप बनाएंगे जो सबसे बुनियादी ऑपरेशन प्रदर्शित करता है:

  • सृष्टि
  • आईडी द्वारा पुनर्प्राप्ति
  • क्वेरी
  • अद्यतन कर रहा है
  • विलोपन

एक नया विज़ुअल स्टूडियो समाधान बनाने से शुरू करें और इसमें कंसोल एप्लिकेशन प्रोजेक्ट जोड़ें। चलो इसे RavenDBDemoConsole कहते हैं। क्लाइंट लाइब्रेरी का उपयोग वैसा ही होना चाहिए, यदि रीडर VS कोड या अपने पसंदीदा संपादक का उपयोग करता है।

अगला, हमें आवश्यक संदर्भ जोड़ना होगा। समाधान एक्सप्लोरर फलक में संदर्भ नोड पर राइट-क्लिक करें और प्रबंधित करें NuGet संकुल। 'RavenDb.Client' के लिए ऑनलाइन ब्राउज़ करें। मैं नवीनतम स्थिर रिलीज का उपयोग करूंगा, जो है - इस लेखन के रूप में - 3.5.2।

चलो कुछ कोड लिखते हैं, हम करेंगे? निम्नलिखित बयानों को जोड़कर शुरू करें:

using Raven.Client;
using Raven.Client.Document;
 

ये हमें RavenDB के IDocumentStore और DocumentStore का उपयोग करने की अनुमति देते हैं, जो कि एक RavenDB उदाहरण से कनेक्ट करने के लिए एक इंटरफ़ेस और इसका आउट-ऑफ-द-बॉक्स कार्यान्वयन है। यह एक शीर्ष-स्तरीय ऑब्जेक्ट है जिसे हमें सर्वर से कनेक्ट करने के लिए उपयोग करने की आवश्यकता है और इसके रेवेनडीबी प्रलेखन की सलाह है कि इसका उपयोग एप्लिकेशन में एक सिंगलटन के रूप में किया जाता है।

इसलिए हम आगे बढ़ेंगे और एक बनाएंगे, लेकिन सादगी के लिए, हम इसके चारों ओर सिंगलटन रैपर को लागू नहीं करेंगे - हम इसे तभी डिस्पोज करेंगे जब प्रोग्राम से बाहर निकल जाए इसलिए कनेक्शन साफ-सुथरे तरीके से बंद हो। अपनी मुख्य विधि में निम्नलिखित कोड जोड़ें:

using (IDocumentStore store = new DocumentStore
{
    Url = "http://live-test.ravendb.net",
    DefaultDatabase = "Pets"
})
{
    store.Initialize();
}
 

जैसा कि शुरुआत में कहा गया था, हम लाइव टेस्ट रैवेनडीबी इंस्टेंस का उपयोग करते हैं, हम इसका पता DocumentStore की Url प्रॉपर्टी के रूप में लगाते हैं। हम इस मामले में, "पालतू जानवर" एक डिफ़ॉल्ट डेटाबेस नाम भी निर्दिष्ट करते हैं। यदि डेटाबेस अभी तक मौजूद नहीं है, तो RavenDB इसे एक्सेस करने की कोशिश करते समय बनाता है। यदि यह मौजूद है, तो ग्राहक मौजूदा का उपयोग कर सकता है। हमें Initialize() पद्धति को कॉल करने की आवश्यकता है ताकि हम उस पर काम शुरू कर सकें।

इस सरल अनुप्रयोग में, हम मालिकों और पालतू जानवरों को बनाए रखेंगे। हम उनके कनेक्शन के बारे में सोचते हैं क्योंकि एक मालिक के पास पालतू जानवरों की मनमानी संख्या हो सकती है, लेकिन एक पालतू जानवर के पास केवल एक ही मालिक हो सकता है। भले ही वास्तविक दुनिया में, एक पालतू जानवर के मालिकों की मनमानी संख्या हो सकती है, उदाहरण के लिए, एक पति और एक पत्नी, हम इस धारणा का विकल्प चुनेंगे क्योंकि एक दस्तावेज़ डेटाबेस में कई-से-कई रिश्ते कुछ हद तक अलग-अलग हैं । संबंधपरक डेटाबेस और अपने खुद के एक विषय के हकदार हैं। मैंने इस डोमेन को चुना है क्योंकि यह समझ में आता है।

इसलिए हमें अब अपने डोमेन ऑब्जेक्ट प्रकारों को परिभाषित करना चाहिए:

public class Owner
{
    public Owner()
    {
        Pets = new List<Pet>();
    }

    public string Id { get; set; }
    public string Name { get; set; }
    public List<Pet> Pets { get; set; }

    public override string ToString()
    {
        return
            "Owner's Id: " + Id + "\n" +
            "Owner's name: " + Name + "\n" +
            "Pets:\n\t" +
            string.Join("\n\t", Pets.Select(p => p.ToString()));
    }
}

public class Pet
{
    public string Color { get; set; }
    public string Name { get; set; }
    public string Race { get; set; }

    public override string ToString()
    {
        return string.Format("{0}, a {1} {2}", Name, Color, Race);
    }
}
 

यहाँ ध्यान देने योग्य कुछ बातें हैं:

सबसे पहले, हमारे Owner शून्य या अधिक Pet हो सकते हैं। ध्यान दें कि Owner वर्ग के पास Id नामक एक संपत्ति है जबकि Pet वर्ग नहीं है। ऐसा इसलिए है क्योंकि Pet वस्तुओं को Owner वस्तुओं के अंदर संग्रहीत किया जाएगा, जो कि इस तरह के रिश्ते को एक संबंधपरक डेटाबेस में कैसे कार्यान्वित किया जाएगा, यह बिल्कुल अलग है।

कोई यह तर्क दे सकता है कि इसे इस तरह लागू नहीं किया जाना चाहिए - और यह सही हो सकता है, यह वास्तव में आवश्यकताओं पर निर्भर करता है। अंगूठे के एक नियम के रूप में, अगर एक Pet एक Owner बिना मौजूद होने का मतलब रखता है, तो इसे एम्बेड नहीं किया जाना चाहिए, लेकिन अपने स्वयं के पहचानकर्ता के साथ मौजूद होना चाहिए। हमारे आवेदन में, हम मानते हैं कि एक Pet को केवल एक पालतू जानवर माना जाता है यदि उसके पास कोई मालिक है, अन्यथा यह एक क्रेटर या जानवर होगा। इस कारण से, हम Pet श्रेणी में एक Id संपत्ति नहीं जोड़ते हैं।

दूसरे, ध्यान दें कि मालिक वर्ग की पहचानकर्ता एक स्ट्रिंग है क्योंकि यह आमतौर पर रेवेनडीबी प्रलेखन में उदाहरणों में दिखाया गया है। रिलेशनल डेटाबेस के लिए उपयोग किए जाने वाले कई डेवलपर्स इसे एक बुरा अभ्यास मान सकते हैं, जो आमतौर पर संबंधपरक दुनिया में समझ में आता है। लेकिन क्योंकि RavenDB अपने कार्यों को करने के लिए Lucene.Net का उपयोग करता है और क्योंकि Lucene.Net स्ट्रिंग्स के साथ काम करने में माहिर है, यह पूरी तरह से यहाँ स्वीकार्य है - साथ ही, हम एक दस्तावेज़ डेटाबेस के साथ काम कर रहे हैं जो JSON और, afterall, मूल रूप से सब कुछ एक स्ट्रिंग के रूप में दर्शाया गया है। JSON में।

Id प्रॉपर्टी के बारे में एक और बात ध्यान देने योग्य है कि यह अनिवार्य नहीं है। वास्तव में, रेवेनडीबी अपने स्वयं के मेटाडेटा को हमारे द्वारा सहेजे गए किसी भी दस्तावेज़ में संलग्न करता है, इसलिए यदि हम इसे परिभाषित नहीं करते हैं, तो रवैनबीडी को हमारी वस्तुओं के साथ कोई समस्या नहीं होगी। हालांकि, यह आमतौर पर आसान पहुंच के लिए परिभाषित किया गया है।

इससे पहले कि हम देखें कि हम अपने कोड से रेवेनडीबी का उपयोग कैसे कर सकते हैं, चलो कुछ सामान्य सहायक विधियों को परिभाषित करते हैं। ये स्व-व्याख्यात्मक होना चाहिए।

// Returns the entered string if it is not empty, otherwise, keeps asking for it.
private static string ReadNotEmptyString(string message)
{
    Console.WriteLine(message);
    string res;
    do
    {
        res = Console.ReadLine().Trim();
        if (res == string.Empty)
        {
            Console.WriteLine("Entered value cannot be empty.");
        }
    } while (res == string.Empty);

    return res;
}

// Will use this to prevent text from being cleared before we've read it.
private static void PressAnyKeyToContinue()
{
    Console.WriteLine();
    Console.WriteLine("Press any key to continue.");
    Console.ReadKey();
}

// Prepends the 'owners/' prefix to the id if it is not present (more on it later)
private static string NormalizeOwnerId(string id)
{
    if (!id.ToLower().StartsWith("owners/"))
    {
        id = "owners/" + id;
    }

    return id;
}

// Displays the menu
private static void DisplayMenu()
{
    Console.WriteLine("Select a command");
    Console.WriteLine("C - Create an owner with pets");
    Console.WriteLine("G - Get an owner with its pets by Owner Id");
    Console.WriteLine("N - Query owners whose name starts with...");
    Console.WriteLine("P - Query owners who have a pet whose name starts with...");
    Console.WriteLine("R - Rename an owner by Id");
    Console.WriteLine("D - Delete an owner by Id");
    Console.WriteLine();
}
 

और हमारी मुख्य विधि:

private static void Main(string[] args)
{
    using (IDocumentStore store = new DocumentStore
    {
        Url = "http://live-test.ravendb.net", 
        DefaultDatabase = "Pets"
    })
    {
        store.Initialize();

        string command;
        do
        {
            Console.Clear();
            DisplayMenu();

            command = Console.ReadLine().ToUpper();
            switch (command)
            {
                case "C":
                    Creation(store);
                    break;
                case "G":
                    GetOwnerById(store);
                    break;
                case "N":
                    QueryOwnersByName(store);
                    break;
                case "P":
                    QueryOwnersByPetsName(store);
                    break;
                case "R":
                    RenameOwnerById(store);
                    break;
                case "D":
                    DeleteOwnerById(store);
                    break;
                case "Q":
                    break;
                default:
                    Console.WriteLine("Unknown command.");
                    break;
            }
        } while (command != "Q");
    }
}
 

सृष्टि

आइए देखें कि हम कुछ वस्तुओं को रेवेनडीबी में कैसे सहेज सकते हैं। आइए निम्नलिखित सामान्य तरीकों को परिभाषित करें:

private static Owner CreateOwner()
{
    string name = ReadNotEmptyString("Enter the owner's name.");

    return new Owner { Name = name };
}

private static Pet CreatePet()
{
    string name = ReadNotEmptyString("Enter the name of the pet.");
    string race = ReadNotEmptyString("Enter the race of the pet.");
    string color = ReadNotEmptyString("Enter the color of the pet.");

    return new Pet
    {
        Color = color,
        Race = race,
        Name = name
    };
}

private static void Creation(IDocumentStore store)
{
    Owner owner = CreateOwner();
    Console.WriteLine(
        "Do you want to create a pet and assign it to {0}? (Y/y: yes, anything else: no)", 
        owner.Name);

    bool createPets = Console.ReadLine().ToLower() == "y";
    do
    {
        owner.Pets.Add(CreatePet());

        Console.WriteLine("Do you want to create a pet and assign it to {0}?", owner.Name);
        createPets = Console.ReadLine().ToLower() == "y";
    } while (createPets);

    using (IDocumentSession session = store.OpenSession())
    {
        session.Store(owner);
        session.SaveChanges();
    }
}
 

अब देखते हैं कि यह कैसे काम करता है। हमने Owner वस्तुओं को बनाने के लिए कुछ सरल C # तर्क को परिभाषित किया है और जब तक उपयोगकर्ता की इच्छा नहीं है तब तक इसे Pet वस्तुओं को बनाते और असाइन करते रहें। जिस हिस्से में रेवेनडीबी चिंतित है और इस तरह इस लेख का ध्यान केंद्रित है कि हम वस्तुओं को कैसे बचाते हैं।

अपने Pet के साथ-साथ नए बनाए गए Owner को बचाने के लिए, हमें सबसे पहले एक सत्र खोलने की जरूरत है, जो IDocumentSession लागू IDocumentSession । हम डॉक्यूमेंट स्टोर ऑब्जेक्ट पर OpenSession को कॉल करके एक बना सकते हैं।

इसलिए, अंतर पर ध्यान दें, जबकि दस्तावेज़ स्टोर एक स्थायी ऑब्जेक्ट है जो आम तौर पर एप्लिकेशन के पूरे जीवनकाल के दौरान मौजूद रहता है, IDocumentSession एक अल्पकालिक, हल्की वस्तु है। यह उन ऑपरेशनों की एक श्रृंखला का प्रतिनिधित्व करता है जिन्हें हम एक बार में (या कम से कम, डेटाबेस में कुछ कॉल में) निष्पादित करना चाहते हैं।

रेवेनडीबी जोर देता है (और कुछ बलों) कि आप सर्वर को राउंडट्रिप्स की अत्यधिक संख्या से बचाते हैं, ऐसा कुछ जिसे वे रेवेनडी वेबसाइट पर 'क्लाइंट-सर्वर चैटर प्रोटेक्शन' कहते हैं। इस कारण से, एक सत्र में एक डिफ़ॉल्ट सीमा होती है कि कितने डेटाबेस इसे कहते हैं, यह सहन करेगा, और इसलिए जब एक सत्र खोला जाता है और उसका निपटान किया जाता है, तो उस पर ध्यान देना चाहिए। क्योंकि इस उदाहरण में, हम एक Owner और उसके Pet के निर्माण को एक ऑपरेशन के रूप में मानते हैं जिसे अपने दम पर निष्पादित किया जाना चाहिए, हम एक सत्र में ऐसा करते हैं और फिर हम इसे निपटान करते हैं।

हम दो और विधि कॉल देख सकते हैं जो हमारे लिए रूचिकर हैं:

  • session.Store(owner) , जो बचत के लिए ऑब्जेक्ट को पंजीकृत करता है, और इसके अतिरिक्त, यदि यह अभी तक सेट नहीं है, तो ऑब्जेक्ट की Id प्रॉपर्टी को सेट करता है। तथ्य यह है कि पहचानकर्ता संपत्ति को Id कहा जाता है इसलिए एक सम्मेलन है।
  • session.Savehanges() RavenDB सर्वर को निष्पादित करने के लिए वास्तविक संचालन भेजता है, सभी लंबित संचालन को शुरू करता है।

आईडी द्वारा पुनर्प्राप्ति

एक अन्य सामान्य ऑपरेशन किसी वस्तु को उसके पहचानकर्ता द्वारा प्राप्त करना है। संबंधपरक दुनिया में, हम सामान्य रूप से पहचानकर्ता को निर्दिष्ट करते हुए Where अभिव्यक्ति का उपयोग करते हैं। लेकिन क्योंकि रेवेनडीबी में, प्रत्येक क्वेरी इंडेक्स का उपयोग करके की जाती है, जो बासी हो सकती है, यह लेने के लिए दृष्टिकोण नहीं है - वास्तव में, रवेनडीबी एक अपवाद फेंकता है यदि हम आईडी द्वारा क्वेरी करने का प्रयास करते हैं। इसके बजाय, हमें आईडी निर्दिष्ट करते हुए Load<T> विधि का उपयोग करना चाहिए। हमारे मेनू तर्क के साथ पहले से ही, हमें केवल उस विधि को परिभाषित करने की आवश्यकता है जो वास्तव में अनुरोधित डेटा को लोड करता है और इसके विवरण प्रदर्शित करता है:

private static void GetOwnerById(IDocumentStore store)
{
    Owner owner;
    string id = NormalizeOwnerId(ReadNotEmptyString("Enter the Id of the owner to display."));

    using (IDocumentSession session = store.OpenSession())
    {
        owner = session.Load<Owner>(id);
    }

    if (owner == null)
    {
        Console.WriteLine("Owner not found.");
    }
    else
    {
        Console.WriteLine(owner);
    }

    PressAnyKeyToContinue();
}
 

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

RavenDB को Id से पहले वाले दस्तावेज़ प्रकार उपसर्ग की आवश्यकता है - जो NormalizeOwnerId के कॉलिंग का कारण है। यदि निर्दिष्ट आईडी के साथ कोई दस्तावेज़ मौजूद नहीं है, तो null वापस आ गया है।

क्वेरी

एक जिसमें हम से अधिक की स्वयं की संपत्तियों क्वेरी: हम यहाँ प्रश्नों के दो प्रकार देखेंगे Owner दस्तावेजों और एक जिसमें हम क्वेरी पर एम्बेडेड Pet वस्तुओं।

आइए सरल से शुरू करते हैं, जिसमें हम उन Owner दस्तावेजों की क्वेरी करते हैं जिनके Name संपत्ति निर्दिष्ट स्ट्रिंग से शुरू होती है।

private static void QueryOwnersByName(IDocumentStore store)
{
    string namePart = ReadNotEmptyString("Enter a name to filter by.");

    List<Owner> result;
    using (IDocumentSession session = store.OpenSession())
    {
        result = session.Query<Owner>()
           .Where(ow => ow.Name.StartsWith(namePart))
           .Take(10)
           .ToList();
    }

    if (result.Count > 0)
    {
        result.ForEach(ow => Console.WriteLine(ow));
    }
    else
    {
        Console.WriteLine("No matches.");
    }
    PressAnyKeyToContinue();
}
 

एक बार फिर, क्योंकि हम एक स्वतंत्र कार्य के रूप में क्वेरी करना चाहते हैं, हम एक सत्र खोलते हैं। हम सत्र ऑब्जेक्ट पर Query<TDocumentType> कॉल करके एक दस्तावेज़ संग्रह पर क्वेरी कर सकते हैं। यह एक IRavenQueryable<TDocumentType> ऑब्जेक्ट देता है, जिस पर हम सामान्य LINQ- विधियों के साथ-साथ कुछ रेवेनबिक-विशिष्ट एक्सटेंशन कह सकते हैं। हम यहां एक साधारण फ़िल्टरिंग करते हैं, और शर्त यह है कि Name संपत्ति का मूल्य दर्ज स्ट्रिंग के साथ शुरू होता है। हम परिणाम सेट के पहले 10 आइटम लेते हैं और इसकी एक सूची बनाते हैं। परिणाम सेट आकार को ठीक से निर्दिष्ट करने पर ध्यान देना चाहिए - रावेनबीडी द्वारा किए गए नाटक में एक और रक्षात्मक प्रवर्तन है जिसे अनबाउंडेड परिणाम सुरक्षा कहा जाता है। इसका मतलब है कि (डिफ़ॉल्ट रूप से) केवल पहले 128 आइटम वापस आ गए हैं।

हमारी दूसरी क्वेरी निम्न की तरह दिखती है:

private static void QueryOwnersByPetsName(IDocumentStore store)
{
    string namePart = ReadNotEmptyString("Enter a name to filter by.");

    List<Owner> result;
    using (IDocumentSession session = store.OpenSession())
    {
       result = session.Query<Owner>()
           .Where(ow => ow.Pets.Any(p => p.Name.StartsWith(namePart)))
           .Take(10)
           .ToList();
    }

    if (result.Count > 0)
    {
        result.ForEach(ow => Console.WriteLine(ow));
    }
    else
    {
        Console.WriteLine("No matches.");
    }
    PressAnyKeyToContinue();
}
 

यह अधिक जटिल नहीं है, मैंने इसे प्रदर्शित करने के लिए लिखा है कि एम्बेडेड ऑब्जेक्ट गुणों पर स्वाभाविक रूप से क्वेरी करना संभव है। यह क्वेरी केवल पहले 10 Owner है, जिनके पास कम से कम एक Pet जिसका नाम दर्ज मूल्य से शुरू होता है।

विलोपन

हमारे पास विलोपन करने के लिए दो विकल्प हैं। एक दस्तावेज़ पहचानकर्ता को पास करना है, जो उपयोगी है यदि हमारे पास मेमोरी में ऑब्जेक्ट नहीं है, लेकिन हमारे पास पहचानकर्ता है और हम डेटाबेस के लिए अन्यथा परिहार्य राउंडट्रिप को रोकना चाहते हैं। दूसरा रास्ता, जाहिर है, तब रेवेनडीबी को बचाई गई वास्तविक वस्तु को पास करना है। हम यहां पहला विकल्प देखेंगे, दूसरा केवल एक ओवरलोड का उपयोग कर रहा है और एक उपयुक्त वस्तु को पारित कर रहा है:

private static void DeleteOwnerById(IDocumentStore store)
{
    string id = NormalizeOwnerId(ReadNotEmptyString("Enter the Id of the owner to delete."));

    using (IDocumentSession session = store.OpenSession())
    {
        session.Delete(id);
        session.SaveChanges();
    }
}
 

एक बार फिर, हमें अपना काम करने के लिए एक सत्र खोलने की आवश्यकता है। जैसा कि पहले उल्लेख, यहाँ हम करने के लिए इसके पहचानकर्ता पारित करके वांछित वस्तु को नष्ट Delete विधि। पहचानकर्ता उपसर्ग यहां भी उसी तरह होना चाहिए, जैसे Load विधि के मामले में था। वास्तव में डिलीट कमांड को डेटाबेस में भेजने के लिए, हमें SaveChanges विधि को कॉल करने की आवश्यकता है, जो कि बस उसी सत्र में पंजीकृत किसी भी अन्य लंबित संचालन के साथ, ऐसा करेगी।

अद्यतन कर रहा है

और अंत में, हम दस्तावेजों को अपडेट करने के तरीके पर एक नज़र डालेंगे। असल में, हमारे पास ऐसा करने के दो तरीके हैं। पहला सीधा है, हम एक दस्तावेज़ को लोड करते हैं, इसके गुणों को आवश्यक रूप से अपडेट करते हैं, फिर इसे Store विधि में पास करते हैं। यह लोडिंग और बचत के प्रदर्शन के अनुसार सीधा होना चाहिए, लेकिन कुछ चीजें ध्यान देने योग्य हैं।

सबसे पहले, रेवेनडीबी क्लाइंट लाइब्रेरी एक परिवर्तन ट्रैकर का उपयोग करती है जो किसी भी दस्तावेज को वास्तव में Store किए बिना इसे तब तक अपडेट करना संभव बनाता है जब तक कि सत्र लोड किया गया सत्र अभी भी खुला है। इस स्थिति में, सत्र को SaveChanges करने के लिए SaveChanges कॉल करना अद्यतन को स्थान देने के लिए पर्याप्त है।

दूसरे, काम करने के लिए, ऑब्जेक्ट को स्पष्ट रूप से अपने पहचानकर्ता को सेट करने की आवश्यकता होती है ताकि रेवेनडीबी यह पता लगा सके कि क्या अद्यतन करना है।

इन के साथ कहा, हम केवल अद्यतन करने के अन्य तरीके पर एक नज़र डालेंगे। पैचिंग नामक एक अवधारणा है, जिसका उपयोग दस्तावेजों को अपडेट करने के लिए किया जा सकता है। जैसे यह डिलीट के मामले में था, वैसे ही इसके उपयोग परिदृश्य भी हैं। अपडेट करने के लिए पिछली पद्धति का उपयोग करना एक अच्छा तरीका है यदि हमारे पास पहले से ही मेमोरी में ऑब्जेक्ट है और / या हम इसके प्रकार की सुरक्षा का उपयोग करना चाहते हैं। यदि हम पहले से ही मेमोरी में ऑब्जेक्ट नहीं रखते हैं, तो पैचिंग का उपयोग करना विकल्प है यदि हम डेटाबेस के लिए अन्यथा अनावश्यक राउंडट्रिप से बचना चाहते हैं। नकारात्मक पक्ष यह है कि हम कुछ प्रकार की सुरक्षा खो देते हैं, क्योंकि हमें सादे तार का उपयोग करके अपडेट करने के लिए गुणों को निर्दिष्ट करना चाहिए (कुछ भी नहीं जो कुछ LINQ- मैजिक हल नहीं कर सकता)। आइए देखें कोड:

private static void RenameOwnerById(IDocumentStore store)
{
    string id = NormalizeOwnerId(ReadNotEmptyString("Enter the Id of the owner to rename."));
    string newName = ReadNotEmptyString("Enter the new name.");

    store.DatabaseCommands.Patch(id, new Raven.Abstractions.Data.PatchRequest[]{
        new Raven.Abstractions.Data.PatchRequest
        {
            Name = "Name",
            Value = newName
        }
    });
}
 

जो इसे लपेटता है। आपको कोड टुकड़े को कंसोल ऐप में पेस्ट करके काम करने वाले उदाहरण को देखने में सक्षम होना चाहिए।

स्थापना या सेटअप

रैवेंडब स्थापित करने या स्थापित करने पर विस्तृत निर्देश।