किसी विधि के लिए IObservable बनाने का एक अच्छा तरीका क्या है?

Question

मान लें, हम एक वर्ग है:

public class Foo 
{ 
    public string Do(int param) 
    { 
    } 
} 

मैं मानों द्वारा उत्पादित किया जा रहा है विधि करो का एक नमूदार बनाना चाहते हैं। ऐसा करने का एक तरीका यह होगा कि से पर कॉल किया जा रहा है और पर्यवेक्षण योग्य उपयोग करें। से देखने योग्य बनाने के लिए उपयोग करें। लेकिन किसी भी तरह से मैं सिर्फ कार्य के लिए एक घटना के निर्माण के बारे में अच्छा महसूस नहीं करता हूं। इसे करने का कोई बेहतर तरीका है?

Answer 1

मैट का जवाब मुझे इस बारे में सोच कर दिया। नमूना कोड के साथ एक अच्छा लेख है जो स्ट्रक्चर मैप के साथ कार्यान्वयन दिखाता है।

http://www.codeproject.com/KB/architecture/event_aggregator.aspx

Answer 2

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

public class Foo 
{ 
    DoObservable _doValues = new DoObservable(); 

    public IObservable<String> DoValues 
    { 
     return _doValues; 
    } 

    public string Do(int param) 
    { 
     string result; 
     // whatever 
     _doValues.Notify(result); 
    } 
} 

public class DoObservable : IObservable<String> 
{ 
    List<IObserver<String>> _observers = new List<IObserver<String>>(); 

    public void Notify(string s) 
    { 
     foreach (var obs in _observers) obs.OnNext(s); 
    } 

    public IObserver<String> Subscribe(IObserver<String> observer) 
    { 
     _observers.Add(observer); 
     return observer; 
    } 
} 

आपका वर्ग अब एक Observable<String> संपत्ति जो एक तरह से मान Do विधि से लौटे की सदस्यता के लिए प्रदान करता है:

public class StringWriter : IObserver<String> 
{ 
    public void OnNext(string value) 
    { 
     Console.WriteLine("Do returned " + value); 
    } 

    // and the other IObserver<String> methods 
} 

var subscriber = myFooInstance.DoValues.Subscribe(new StringWriter()); 
// from now on, anytime myFooInstance.Do() is called, the value it 
// returns will be written to the console by the StringWriter observer. 

मैं प्रतिक्रियाशील ढांचे में बहुत ज्यादा हाथ आजमाया नहीं गया है, लेकिन मैं लगता है कि यह इस बात के करीब है कि आप यह कैसे करेंगे।

public class Foo 
{ 
    private readonly Subject<string> _doValues = new Subject<string>(); 

    public IObservable<string> DoValues { get { return _doValues; } } 

    public string Do(int param) 
    { 
     var ret = (param * 2).ToString(); 
     _doValues.OnNext(ret); 
     return ret; 
    } 
} 


var foo = new Foo(); 
foo.DoValues.Subscribe(Console.WriteLine); 
foo.Do(2); 

Answer 3

मैं EventAggregator मॉडल पर दिखेगा:

Answer 4

आम तौर पर आप विषयों का उपयोग कर से बचने के लिए चाहते हैं। मेरे प्रयोग में यह एक संकेत है कि आप कुछ गलत कर रहे हैं। अवलोकन योग्य। बनाना या शायद उत्पन्न करना सामान्य रूप से बेहतर फिट बैठता है।

मुझे यह देखने में दिलचस्पी होगी कि आप वास्तव में क्या करने की कोशिश कर रहे हैं यह देखने के लिए कि क्या हम एक बेहतर उत्तर प्रदान कर सकते हैं। ली

Answer 5

अवलोकन योग्य। जनरेट आपकी समस्या हल करता है, हालांकि आपको स्थिति का उपयोग करने और अपने नमूने के लिए जारी रखने की आवश्यकता नहीं है। यह सिर्फ बनाता है और वस्तु और लगातार छदाम() करने के लिए कॉल के परिणाम देता है:

Observable.Generate (
    new Foo(), 
    item => true, // in your example, this never terminates 
    item => item, // we don't actually do any state transitions 
    item => { return item.DoIt(); } // This is where we emit our value 
); 

अभ्यास में, आप अक्सर कुछ राज्य पर नज़र रखने और कुछ समाप्ति हालत करना चाहते हैं। उत्पन्न करना आसान बनाता है।