रेडिस लेनदेन

यह पृष्ठ सर्विसस्टैकरेडिस सर्विस स्टैक के सी # रेडिस क्लाइंट के साथ परमाणु रेडिस लेनदेन बनाने के उदाहरण प्रदान करता है

Redis में कस्टम परमाणु संचालन कैसे बनाएं #

रेडिस की मुख्य विशेषताओं में से एक कस्टम परमाणु संचालन के निर्माण की क्षमता है। यह Redis के MULTI/EXEC/DISCARD संचालन का उपयोग करके प्राप्त किया जाता है।

सर्विसस्टैक का C# Redis क्लाइंट आपको एक ही लेन-देन के भीतर किसी भी IRedisClient ऑपरेशन को संयोजित करने की अनुमति देने के लिए सुविधा विधियों के साथ एक जोरदार टाइप IRedisTransaction (स्ट्रिंग्स के लिए) और IRedisTypedTransaction (POCO प्रकारों के लिए) API प्रदान करके Redis लेनदेन का उपयोग करना आसान बनाता है।

IRedisClient.CreateTransaction() . पर कॉल करके लेन-देन किया जाता है . वहां से आप IRedisTransaction.QueueCommand() में से किसी एक का उपयोग करके लेन-देन का हिस्सा बनने के लिए सभी कार्यों को 'कतार' कर सकते हैं। अधिभार। उसके बाद आप IRedisTransaction.Commit() . पर कॉल करके सभी ऑपरेशन निष्पादित कर सकते हैं जो सभी कतारबद्ध आदेशों को निष्पादित करने और उनके कॉलबैक को संसाधित करने के लिए रेडिस सर्वर को 'EXEC' कमांड भेजेगा।

अगर आप Commit() . पर कॉल नहीं करते हैं उपयोग ब्लॉक के अंत से पहले, Dispose() विधि स्वचालित रूप से Rollback() को आमंत्रित करेगी जो 'DISCARD' कमांड को वर्तमान लेन-देन के निपटान और Redis क्लाइंट कनेक्शन को उसकी पिछली स्थिति में वापस रीसेट करने के लिए भेजेगा।

Redis Transaction उदाहरण #

नीचे एक सरल उदाहरण दिया गया है जिसमें दिखाया गया है कि कॉलबैक के साथ और उसके बिना Redis संचालन को कैसे कतारबद्ध किया जाए।

int callbackResult;
using (var trans = redis.CreateTransaction())
{
  trans.QueueCommand(r => r.Increment("key"));  
  trans.QueueCommand(r => r.Increment("key"), i => callbackResult = i);  

  trans.Commit();
}
//The value of "key" is incremented twice. The latest value of which is also stored in 'callbackResult'.

अन्य सामान्य उदाहरण #

पूर्ण-स्रोत कोड और अन्य सामान्य उदाहरण सामान्य लेनदेन परीक्षण पृष्ठ पर पाए जा सकते हैं।

[Test]
public void Can_Set_and_Expire_key_in_atomic_transaction()
{
    var oneSec = TimeSpan.FromSeconds(1);

    Assert.That(Redis.GetString("key"), Is.Null);
    using (var trans = Redis.CreateTransaction())                  //Calls 'MULTI'
    {
        trans.QueueCommand(r => r.SetString("key", "a"));      //Queues 'SET key a'
        trans.QueueCommand(r => r.ExpireKeyIn("key", oneSec)); //Queues 'EXPIRE key 1'

        trans.Commit();                                        //Calls 'EXEC'

    }                                                              //Calls 'DISCARD' if 'EXEC' wasn't called

    Assert.That(Redis.GetString("key"), Is.EqualTo("a"));
    Thread.Sleep(TimeSpan.FromSeconds(2));
    Assert.That(Redis.GetString("key"), Is.Null);
}

[Test]
public void Can_Pop_priority_message_from_SortedSet_and_Add_to_workq_in_atomic_transaction()
{
    var messages = new List<string> { "message4", "message3", "message2" };

    Redis.AddToList("workq", "message1");

    var priority = 1;
    messages.ForEach(x => Redis.AddToSortedSet("prioritymsgs", x, priority++));

    var highestPriorityMessage = Redis.PopFromSortedSetItemWithHighestScore("prioritymsgs");

    using (var trans = Redis.CreateTransaction())
    {
        trans.QueueCommand(r => r.RemoveFromSortedSet("prioritymsgs", highestPriorityMessage));
        trans.QueueCommand(r => r.AddToList("workq", highestPriorityMessage));	

        trans.Commit();											
    }

    Assert.That(Redis.GetAllFromList("workq"), 
        Is.EquivalentTo(new List<string> { "message1", "message2" }));
    Assert.That(Redis.GetAllFromSortedSet("prioritymsgs"), 
        Is.EquivalentTo(new List<string> { "message3", "message4" }));
}

ऑल-इन-वन उदाहरण #

यह और अन्य उदाहरण RedisTransactionTests.cs परीक्षण सूट को देखकर पाया जा सकता है।

यहां एक ही लेन-देन के भीतर विभिन्न रेडिस परिचालनों के संयोजन का एक-एक-एक उदाहरण दिया गया है:

[Test]
public void Supports_different_operation_types_in_same_transaction()
{
    var incrementResults = new List<int>();
    var collectionCounts = new List<int>();
    var containsItem = false;

    Assert.That(Redis.GetString(Key), Is.Null);
    using (var trans = Redis.CreateTransaction())
    {
        trans.QueueCommand(r => r.Increment(Key), intResult => incrementResults.Add(intResult));
        trans.QueueCommand(r => r.AddToList(ListKey, "listitem1"));
        trans.QueueCommand(r => r.AddToList(ListKey, "listitem2"));
        trans.QueueCommand(r => r.AddToSet(SetKey, "setitem"));
        trans.QueueCommand(r => r.SetContainsValue(SetKey, "setitem"), b => containsItem = b);
        trans.QueueCommand(r => r.AddToSortedSet(SortedSetKey, "sortedsetitem1"));
        trans.QueueCommand(r => r.AddToSortedSet(SortedSetKey, "sortedsetitem2"));
        trans.QueueCommand(r => r.AddToSortedSet(SortedSetKey, "sortedsetitem3"));
        trans.QueueCommand(r => r.GetListCount(ListKey), intResult => collectionCounts.Add(intResult));
        trans.QueueCommand(r => r.GetSetCount(SetKey), intResult => collectionCounts.Add(intResult));
        trans.QueueCommand(r => r.GetSortedSetCount(SortedSetKey), intResult => collectionCounts.Add(intResult));
        trans.QueueCommand(r => r.Increment(Key), intResult => incrementResults.Add(intResult));

        trans.Commit();
    }

    Assert.That(containsItem, Is.True);
    Assert.That(Redis.GetString(Key), Is.EqualTo("2"));
    Assert.That(incrementResults, Is.EquivalentTo(new List<int> { 1, 2 }));
    Assert.That(collectionCounts, Is.EquivalentTo(new List<int> { 2, 1, 3 }));
    Assert.That(Redis.GetAllFromList(ListKey), Is.EquivalentTo(new List<string> { "listitem1", "listitem2" }));
    Assert.That(Redis.GetAllFromSet(SetKey), Is.EquivalentTo(new List<string> { "setitem" }));
    Assert.That(Redis.GetAllFromSortedSet(SortedSetKey), Is.EquivalentTo(new List<string> { "sortedsetitem1", "sortedsetitem2", "sortedsetitem3" }));
}