प्रतिक्रियाशील एक्सटेंशन (आरएक्स)

Question

का उपयोग कर देरी और डी-डुप्लिकेशंस मैं कुछ संदेशों को बदलने और उन्हें थोड़ी देर के बाद रिले करने के लिए प्रतिक्रियाशील एक्सटेंशन का उपयोग करना चाहता हूं।

संदेशों कुछ इस तरह दिखाई:

• देरी की लंबाई:

  class OutMsg 
  { 
      int GroupId { get; set; } 
      string Content { get; set; } 
      OutMsg(InMsg in) 
      { 
       GroupId = in.GroupId; 
       Content = Transform(in.Content); // function omitted 
      } 
  } 
  

  आवश्यकताओं के एक जोड़े हैं:

  class InMsg 
  { 
      int GroupId { get; set; } 
      int Delay { get; set; } 
      string Content { get; set; } 
  } 
  

  उत्पादन कुछ इस तरह दिखता संदेश की सामग्री पर निर्भर है।

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

को देखते हुए एक नमूदार <InMsg> और एक संदेश समारोह:

IObservable<InMsg> inMsgs = ...; 

void Send(OutMsg o) 
{ 
    ... // publishes transformed messages 
} 

मैं समझता हूँ कि मैं परिवर्तन को करने के लिए का चयन कर सकते हैं।

void SetUp() 
{ 
    inMsgs.Select(i => new OutMsg(i)).Subscribe(Send); 
} 

• कैसे मैं एक संदेश में देरी निर्दिष्ट आवेदन कर सकते हैं? (ध्यान दें कि संदेशों के ऑर्डर डिलीवरी के परिणामस्वरूप इसका परिणाम हो सकता है।)
• मैं उसी समूह आईडी के साथ संदेशों को कैसे डुप्लिकेट कर सकता हूं?
• क्या आरएक्स इस समस्या को हल करने में सक्षम है?
• क्या इसे हल करने का कोई और तरीका है?

Answer 1

आप GroupBy का उपयोग एक IGroupedObservable, Delay बनाने के लिए कर सकते हैं उत्पादन में देरी करने, और Switch यकीन है कि नए मूल्यों अपने समूह में पिछले मान की जगह बनाने के लिए:

IObservable<InMsg> inMessages; 

inMessages 
    .GroupBy(msg => msg.GroupId) 
    .Select(group => 
     { 
      return group.Select(groupMsg => 
       { 
        TimeSpan delay = TimeSpan.FromMilliseconds(groupMsg.Delay); 
        OutMsg outMsg = new OutMsg(); // map InMsg -> OutMsg here 

        return Observable.Return(outMsg).Delay(delay); 
       }) 
       .Switch(); 
     }) 
     .Subscribe(outMsg => Console.Write("OutMsg received")); 

कार्यान्वयन पर एक नोट: यदि एक समूहीकृत मूल्य के बाद पहुंचे संदेश भेजे जाने से (यानी। विलंब के बाद), यह एक नई देरी

Answer 2

आरएक्स ढांचे देरीका उपयोग कर हल करती है शुरू कर देंगे 210 विस्तार विधि। देरी के बाद नियमित LINQ प्रकार लागू करके डी-डुप्लिकेशन के साथ कतार को हल किया जा सकता है, फिर DistinctUntilChanged कर रहा है।

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