Design patterns
देखने वाला

टिप्पणियों

प्रेक्षक / जावा

पर्यवेक्षक पैटर्न एक वर्ग के उपयोगकर्ताओं को उन घटनाओं की सदस्यता देता है जो तब होती हैं जब यह वर्ग डेटा आदि की प्रक्रिया करता है और इन घटनाओं के होने पर उन्हें सूचित किया जाता है। निम्नलिखित उदाहरण में हम एक प्रोसेसिंग क्लास और एक ऑब्जर्वर क्लास बनाते हैं जिसे एक वाक्यांश को संसाधित करते समय अधिसूचित किया जाएगा - अगर यह ऐसे शब्द पाता है जो 5 अक्षरों से अधिक लंबे होते हैं।

LongWordsObserver इंटरफ़ेस पर्यवेक्षक को परिभाषित करता है। घटनाओं के लिए एक पर्यवेक्षक को पंजीकृत करने के लिए इस इंटरफ़ेस को लागू करें।

// an observe that can be registered and receive notifications
public interface LongWordsObserver {
    void notify(WordEvent event);
}

WordEvent वर्ग वह घटना है जिसे कुछ घटनाओं के होने पर पर्यवेक्षक कक्षाओं में भेज दिया जाएगा (इस मामले में, लंबे समय तक शब्द नहीं मिले थे)

// An event class which contains the long word that was found
public class WordEvent {

    private String word;

    public WordEvent(String word) {
        this.word = word;
    }

    public String getWord() {
        return word;
    }
}

PhraseProcessor वर्ग वर्ग है जो दिए गए वाक्यांश प्रक्रियाओं है। यह पर्यवेक्षकों को addObserver विधि का उपयोग करके पंजीकृत करने की अनुमति देता है। एक बार लंबे शब्द पाए जाने के बाद, इन पर्यवेक्षकों को WordEvent क्लास के एक उदाहरण का उपयोग करके बुलाया जाएगा।

import java.util.ArrayList;
import java.util.List;

public class PhraseProcessor {

    // the list of observers
    private List<LongWordsObserver> observers = new ArrayList<>();

    // register an observer
    public void addObserver(LongWordsObserver observer) {
        observers.add(observer);
    }

    // inform all the observers that a long word was found
    private void informObservers(String word) {
        observers.forEach(o -> o.notify(new WordEvent(word)));
    }

    // the main method - process a phrase and look for long words. If such are found,
    // notify all the observers
    public void process(String phrase) {
        for (String word : phrase.split(" ")) {
            if (word.length() > 5) {
                informObservers(word);
            }
        }
    }
}

LongWordsExample वर्ग दिखाता है कि पर्यवेक्षकों को कैसे पंजीकृत किया जाए, process विधि को कॉल करें और लंबे शब्द पाए जाने पर अलर्ट प्राप्त करें।

import java.util.ArrayList;
import java.util.List;

public class LongWordsExample {

    public static void main(String[] args) {

        // create a list of words to be filled when long words were found
        List<String> longWords = new ArrayList<>();

        // create the PhraseProcessor class
        PhraseProcessor processor = new PhraseProcessor();

        // register an observer and specify what it should do when it receives events,
        // namely to append long words in the longwords list
        processor.addObserver(event -> longWords.add(event.getWord()));

        // call the process method 
        processor.process("Lorem ipsum dolor sit amet, consectetuer adipiscing elit");

        // show the list of long words after the processing is done
        System.out.println(String.join(", ", longWords));
        // consectetuer, adipiscing
    }
}

IObservable और IObserver (C #) का उपयोग करते हुए पर्यवेक्षक

IObserver<T> और IObservable<T> .NET में IObservable<T> पैटर्न को लागू करने के लिए इंटरफेस का उपयोग किया जा सकता है

• IObservable<T> इंटरफ़ेस उस वर्ग का प्रतिनिधित्व करता है जो सूचनाएं भेजता है
• IObserver<T> इंटरफ़ेस उन्हें प्राप्त करने वाले वर्ग का प्रतिनिधित्व करता है

public class Stock {
  private string Symbol { get; set; }
  private decimal Price { get; set; }
}

public class Investor : IObserver<Stock> {
  public IDisposable unsubscriber;
  public virtual void Subscribe(IObservable<Stock> provider) {
    if(provider != null) {
      unsubscriber = provider.Subscribe(this);
    }
  }
  public virtual void OnCompleted() {
    unsubscriber.Dispose();
  }
  public virtual void OnError(Exception e) {
  }
  public virtual void OnNext(Stock stock) {
  }
}

public class StockTrader : IObservable<Stock> {
  public StockTrader() {
    observers = new List<IObserver<Stock>>();
  }
  private IList<IObserver<Stock>> observers;
  public IDisposable Subscribe(IObserver<Stock> observer) {
    if(!observers.Contains(observer)) {
      observers.Add(observer);
    }
    return new Unsubscriber(observers, observer);
  }
  public class Unsubscriber : IDisposable {
    private IList<IObserver<Stock>> _observers;
    private IObserver<Stock> _observer;

    public Unsubscriber(IList<IObserver<Stock>> observers, IObserver<Stock> observer) {
      _observers = observers;
      _observer = observer;
    }

    public void Dispose() {
      Dispose(true);
    }
    private bool _disposed = false;
    protected virtual void Dispose(bool disposing) {
      if(_disposed) {
        return;
      }
      if(disposing) {
        if(_observer != null && _observers.Contains(_observer)) {
          _observers.Remove(_observer);
        }
      }
      _disposed = true;
    }
  }
  public void Trade(Stock stock) {
    foreach(var observer in observers) {
      if(stock== null) {
        observer.OnError(new ArgumentNullException());
      }
      observer.OnNext(stock);
    }
  }
  public void End() {
    foreach(var observer in observers.ToArray()) {
      observer.OnCompleted();
    }
    observers.Clear();
  }
}

प्रयोग

...
var provider = new StockTrader();
var i1 = new Investor();
i1.Subscribe(provider);
var i2 = new Investor();
i2.Subscribe(provider);

provider.Trade(new Stock());
provider.Trade(new Stock());
provider.Trade(null);
provider.End();
...

REF: डिजाइन पैटर्न और प्रथाओं .NET में: ऑब्जर्वर पैटर्न