मेरे सहयोगी और मेरे पास विवाद है। हम एक .NET अनुप्रयोग लिख रहे हैं जो बड़ी मात्रा में डेटा को संसाधित करता है। यह डेटा मानकों को प्राप्त करता है, कुछ मानदंडों के अनुसार उन्हें ब्लॉक में समूह समूह और उन ब्लॉक को संसाधित करता है।क्या मुझे अपने इंटरफेस पर IObservable <T> का खुलासा करना चाहिए?
के हम प्रकार Foo कुछ स्रोत पहुंचने के डेटा आइटम नहीं हैं (नेटवर्क से, उदाहरण के लिए) का कहना है कि एक के बाद एक करते हैं। हम सबसेट प्रकार Foo से संबंधित वस्तुओं की इकट्ठा प्रकार Bar में से प्रत्येक के इस तरह के सबसेट है और इस प्रक्रिया वस्तुओं से प्रकार Bar की एक वस्तु का निर्माण करना चाहते हैं।
हम में से एक ने निम्नलिखित डिज़ाइन का सुझाव दिया। इसका मुख्य विषय सीधे हमारे घटकों के इंटरफेस से IObservable<T> ऑब्जेक्ट्स को उजागर कर रहा है।
// ********* Interfaces **********
interface IFooSource
{
// this is the event-stream of objects of type Foo
IObservable<Foo> FooArrivals { get; }
}
interface IBarSource
{
// this is the event-stream of objects of type Bar
IObservable<Bar> BarArrivals { get; }
}
/********* Implementations *********
class FooSource : IFooSource
{
// Here we put logic that receives Foo objects from the network and publishes them to the FooArrivals event stream.
}
class FooSubsetsToBarConverter : IBarSource
{
IFooSource fooSource;
IObservable<Bar> BarArrivals
{
get
{
// Do some fancy Rx operators on fooSource.FooArrivals, like Buffer, Window, Join and others and return IObservable<Bar>
}
}
}
// this class will subscribe to the bar source and do processing
class BarsProcessor
{
BarsProcessor(IBarSource barSource);
void Subscribe();
}
// ******************* Main ************************
class Program
{
public static void Main(string[] args)
{
var fooSource = FooSourceFactory.Create();
var barsProcessor = BarsProcessorFactory.Create(fooSource) // this will create FooSubsetToBarConverter and BarsProcessor
barsProcessor.Subscribe();
fooSource.Run(); // this enters a loop of listening for Foo objects from the network and notifying about their arrival.
}
}
एक और डिजाइन है कि इसकी मुख्य विषय हमारे अपने प्रकाशक/ग्राहक इंटरफेस का उपयोग करने और केवल आवश्यकता आरएक्स कार्यान्वयन के अंदर उपयोग कर रहा है का सुझाव दिया।
//********** interfaces *********
interface IPublisher<T>
{
void Subscribe(ISubscriber<T> subscriber);
}
interface ISubscriber<T>
{
Action<T> Callback { get; }
}
//********** implementations *********
class FooSource : IPublisher<Foo>
{
public void Subscribe(ISubscriber<Foo> subscriber) { /* ... */ }
// here we put logic that receives Foo objects from some source (the network?) publishes them to the registered subscribers
}
class FooSubsetsToBarConverter : ISubscriber<Foo>, IPublisher<Bar>
{
void Callback(Foo foo)
{
// here we put logic that aggregates Foo objects and publishes Bars when we have received a subset of Foos that match our criteria
// maybe we use Rx here internally.
}
public void Subscribe(ISubscriber<Bar> subscriber) { /* ... */ }
}
class BarsProcessor : ISubscriber<Bar>
{
void Callback(Bar bar)
{
// here we put code that processes Bar objects
}
}
//********** program *********
class Program
{
public static void Main(string[] args)
{
var fooSource = fooSourceFactory.Create();
var barsProcessor = barsProcessorFactory.Create(fooSource) // this will create BarsProcessor and perform all the necessary subscriptions
fooSource.Run(); // this enters a loop of listening for Foo objects from the network and notifying about their arrival.
}
}
आपको कौन सा लगता है बेहतर है? IObservable<T> का खुलासा करना और हमारे घटकों को आरएक्स ऑपरेटरों से नई घटना धाराएं बनाना, या अपने स्वयं के प्रकाशक/ग्राहक इंटरफेस को परिभाषित करना और आवश्यकता होने पर आंतरिक रूप से आरएक्स का उपयोग करना?
पहले डिजाइन में हमारे इंटरफेस के उपभोक्ता उसका/उसकी उंगलियों पर आरएक्स की पूरी शक्ति है और किसी भी आरएक्स ऑपरेटरों प्रदर्शन कर सकते हैं:
ये कुछ चीजें हैं डिजाइन के बारे में विचार करने के लिए कर रहे हैं। हम में से एक का दावा है कि यह एक फायदा है और अन्य दावे यह है कि यह एक कमी है।
दूसरे डिजाइन हमें हुड के नीचे किसी भी प्रकाशक/ग्राहक वास्तुकला का उपयोग करने की अनुमति देता है। पहला डिजाइन हमें आरएक्स से जोड़ता है।
यदि हम आरएक्स की शक्ति का उपयोग करना चाहते हैं, तो इसे दूसरे डिजाइन में अधिक काम की आवश्यकता है क्योंकि हमें कस्टम प्रकाशक/ग्राहक कार्यान्वयन को आरएक्स और पीठ में अनुवाद करने की आवश्यकता है। इसके लिए प्रत्येक कक्षा प्रसंस्करण करने की इच्छा रखने वाले प्रत्येक वर्ग के लिए गोंद कोड लिखना आवश्यक है।
मुझे यह प्रश्न पसंद है जिस तरह से आप इसे पसंद करते हैं। "मेरे और मेरे सहयोगी के पास विवाद है।" +1। –
सभी IObservable सामानों को * एक्सटेंशन विधियों * के रूप में क्यों न उजागर करें जो "गोंद कोड" का ख्याल रखते हैं।विकल्प की पेशकश करते समय, सभी ऑब्जेक्ट मॉडल को अपने ऑब्जेक्ट मॉडल से अलग रखता है। 'सार्वजनिक IOervervable AsObservable (यह IPublisher प्रकाशक) 'या कुछ समान –
Will
आपने संतुलित तरीके से प्रश्न पूछने का अच्छा काम किया है। –