デリゲートを使用したC#オブザーバー/オブザーバブルの非常にシンプルな例


131

私は最近C#を掘り下げ始めましたが、オブザーバー/オブザーバブルパターンを言語で実装するときにデリゲートがどのように機能するのか、私の人生では理解できません。

誰かが私にそれがどのように行われるかの非常に単純な例を教えてもらえますか?私これグーグルで調べましたが、私が見つけたすべての例は、問題が具体的すぎるか、「肥大化」しすぎていました。

回答:


218

オブザーバーパターンは通常、イベントで実装されます

次に例を示します。

using System;

class Observable
{
    public event EventHandler SomethingHappened;

    public void DoSomething() =>
        SomethingHappened?.Invoke(this, EventArgs.Empty);
}

class Observer
{
    public void HandleEvent(object sender, EventArgs args)
    {
        Console.WriteLine("Something happened to " + sender);
    }
}

class Test
{
    static void Main()
    {
        Observable observable = new Observable();
        Observer observer = new Observer();
        observable.SomethingHappened += observer.HandleEvent;

        observable.DoSomething();
    }
}

詳細については、リンク先の記事を参照してください。

上記の例では、C#6 null条件演算子を使用して、サブスクライブされていないためnullでDoSomethingあるケースを安全に実装できることに注意してくださいSomethingHappened。古いバージョンのC#を使用している場合は、次のようなコードが必要です。

public void DoSomething()
{
    var handler = SomethingHappened;
    if (handler != null)
    {
        handler(this, EventArgs.Empty);
    }
}

17
自分自身にいくつかの行を保存し、nullチェックを回避するために、初期化する。このようなあなたのイベント:stackoverflow.com/questions/340610/...
ダイナ

1
@Dinah:nullチェックは避けられません。SomethingHappened = null後で設定することもできます(すべてのハンドラーをサブスクライブ解除するための、レイジーで理想的ではない便利な方法)。そのため、常にnullチェックが必要です。
Dan Puzey 2013

4
@DanPuzey:クラス内で実行できますが、それを行わないことを確認することもできます。他のコードでは、サブスクライブとサブスクライブ解除しかできないため、実行できません。クラス内で意図的にnullに設定しないようにする場合は、nullチェックを回避することをお勧めします。
Jon Skeet、

2
@JonSkeet:もちろん、私はあなたがクラスの外でそれを行うことができないのを忘れていました。お詫び!
Dan Puzey 2013

2
DoSomethingのすべてのものを置き換えることができると思いますSomethingHappened?.Invoke(this, EventArgs.Empty);
JuniorMayhéJun

16

以下に簡単な例を示します。

public class ObservableClass
{
    private Int32 _Value;

    public Int32 Value
    {
        get { return _Value; }
        set
        {
            if (_Value != value)
            {
                _Value = value;
                OnValueChanged();
            }
        }
    }

    public event EventHandler ValueChanged;

    protected void OnValueChanged()
    {
        if (ValueChanged != null)
            ValueChanged(this, EventArgs.Empty);
    }
}

public class ObserverClass
{
    public ObserverClass(ObservableClass observable)
    {
        observable.ValueChanged += TheValueChanged;
    }

    private void TheValueChanged(Object sender, EventArgs e)
    {
        Console.Out.WriteLine("Value changed to " +
            ((ObservableClass)sender).Value);
    }
}

public class Program
{
    public static void Main()
    {
        ObservableClass observable = new ObservableClass();
        ObserverClass observer = new ObserverClass(observable);
        observable.Value = 10;
    }
}

注意:

  • これは、オブザーバーをオブザーバブルから外さないというルールに違反します。これは、おそらくこの単純な例には十分ですが、オブザーバーがそのようなイベントにぶら下がらないようにしてください。これを処理する方法は、ObserverClassをIDisposableにして、.Disposeメソッドにコンストラクターのコードの反対を実行させることです。
  • エラーチェックは行われません。少なくともnullチェックはObserverClassのコンストラクターで行われる必要があります

15

このモデルでは、ロジックを実行して「イベント」を発行する発行者がいます。
パブリッシャーは、特定のイベントを受信するためにサブスクライブしたサブスクライバーにのみイベントを送信します。

C#では、任意のオブジェクトが、他のアプリケーションがサブスクライブできる一連のイベントを公開できます。
パブリッシングクラスがイベントを発生させると、サブスクライブされているすべてのアプリケーションに通知されます。
次の図は、このメカニズムを示しています。

ここに画像の説明を入力してください

C#のイベントとデリゲートで可能な最も簡単な例:

コードは自明です。また、コードを明確にするためにコメントを追加しました。

  using System;

public class Publisher //main publisher class which will invoke methods of all subscriber classes
{
    public delegate void TickHandler(Publisher m, EventArgs e); //declaring a delegate
    public TickHandler Tick;     //creating an object of delegate
    public EventArgs e = null;   //set 2nd paramter empty
    public void Start()     //starting point of thread
    {
        while (true)
        {
            System.Threading.Thread.Sleep(300);
            if (Tick != null)   //check if delegate object points to any listener classes method
            {
                Tick(this, e);  //if it points i.e. not null then invoke that method!
            }
        }
    }
}

public class Subscriber1                //1st subscriber class
{
    public void Subscribe(Publisher m)  //get the object of pubisher class
    {
        m.Tick += HeardIt;              //attach listener class method to publisher class delegate object
    }
    private void HeardIt(Publisher m, EventArgs e)   //subscriber class method
    {
        System.Console.WriteLine("Heard It by Listener");
    }

}
public class Subscriber2                   //2nd subscriber class
{
    public void Subscribe2(Publisher m)    //get the object of pubisher class
    {
        m.Tick += HeardIt;               //attach listener class method to publisher class delegate object
    }
    private void HeardIt(Publisher m, EventArgs e)   //subscriber class method
    {
        System.Console.WriteLine("Heard It by Listener2");
    }

}

class Test
{
    static void Main()
    {
        Publisher m = new Publisher();      //create an object of publisher class which will later be passed on subscriber classes
        Subscriber1 l = new Subscriber1();  //create object of 1st subscriber class
        Subscriber2 l2 = new Subscriber2(); //create object of 2nd subscriber class
        l.Subscribe(m);     //we pass object of publisher class to access delegate of publisher class
        l2.Subscribe2(m);   //we pass object of publisher class to access delegate of publisher class

        m.Start();          //starting point of publisher class
    }
}

出力:

リスナーが聞いた

リスナー2がそれを聞いた

リスナーが聞いた

リスナー2がそれを聞いた

聞き取りました。。。(無限回)


6

私は上記の偉大な例をいくつ(いつものようにありがとう一緒に結び付けてきた氏スキート氏Karlsenの異なる観測のカップルを含めて)とオブザーバーでそれらを追跡するためのインタフェースを利用し、観察者に許可します内部リストを介して任意の数のObservableを「観察」するには:

namespace ObservablePattern
{
    using System;
    using System.Collections.Generic;

    internal static class Program
    {
        private static void Main()
        {
            var observable = new Observable();
            var anotherObservable = new AnotherObservable();

            using (IObserver observer = new Observer(observable))
            {
                observable.DoSomething();
                observer.Add(anotherObservable);
                anotherObservable.DoSomething();
            }

            Console.ReadLine();
        }
    }

    internal interface IObservable
    {
        event EventHandler SomethingHappened;
    }

    internal sealed class Observable : IObservable
    {
        public event EventHandler SomethingHappened;

        public void DoSomething()
        {
            var handler = this.SomethingHappened;

            Console.WriteLine("About to do something.");
            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
    }

    internal sealed class AnotherObservable : IObservable
    {
        public event EventHandler SomethingHappened;

        public void DoSomething()
        {
            var handler = this.SomethingHappened;

            Console.WriteLine("About to do something different.");
            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
    }

    internal interface IObserver : IDisposable
    {
        void Add(IObservable observable);

        void Remove(IObservable observable);
    }

    internal sealed class Observer : IObserver
    {
        private readonly Lazy<IList<IObservable>> observables =
            new Lazy<IList<IObservable>>(() => new List<IObservable>());

        public Observer()
        {
        }

        public Observer(IObservable observable) : this()
        {
            this.Add(observable);
        }

        public void Add(IObservable observable)
        {
            if (observable == null)
            {
                return;
            }

            lock (this.observables)
            {
                this.observables.Value.Add(observable);
                observable.SomethingHappened += HandleEvent;
            }
        }

        public void Remove(IObservable observable)
        {
            if (observable == null)
            {
                return;
            }

            lock (this.observables)
            {
                observable.SomethingHappened -= HandleEvent;
                this.observables.Value.Remove(observable);
            }
        }

        public void Dispose()
        {
            for (var i = this.observables.Value.Count - 1; i >= 0; i--)
            {
                this.Remove(this.observables.Value[i]);
            }
        }

        private static void HandleEvent(object sender, EventArgs args)
        {
            Console.WriteLine("Something happened to " + sender);
        }
    }
}

これは古いことはわかっていますが、これはスレッドセーフに見えますが、そうではありません。Observer.AddとObserver.Removeの両方で、nullチェックはロック内にある必要があります。Disposeもロックを取得し、isDispisedフラグを設定する必要があります。それ以外の場合は、良い完全な例です。
user5151179

5

デリゲートとc#のイベントでオブザーバーパターンを適用することは、わずかなバリエーションであるMSDNによると「イベントパターン」と呼ばれます。

この記事では、古典的な方法とデリゲートとイベントの使用の両方でパターンをC#で適用する方法の適切に構造化された例を紹介します。

オブザーバーのデザインパターンの調査

public class Stock
{

    //declare a delegate for the event
    public delegate void AskPriceChangedHandler(object sender,
          AskPriceChangedEventArgs e);
    //declare the event using the delegate
    public event AskPriceChangedHandler AskPriceChanged;

    //instance variable for ask price
    object _askPrice;

    //property for ask price
    public object AskPrice
    {

        set
        {
            //set the instance variable
            _askPrice = value;

            //fire the event
            OnAskPriceChanged();
        }

    }//AskPrice property

    //method to fire event delegate with proper name
    protected void OnAskPriceChanged()
    {

        AskPriceChanged(this, new AskPriceChangedEventArgs(_askPrice));

    }//AskPriceChanged

}//Stock class

//specialized event class for the askpricechanged event
public class AskPriceChangedEventArgs : EventArgs
{

    //instance variable to store the ask price
    private object _askPrice;

    //constructor that sets askprice
    public AskPriceChangedEventArgs(object askPrice) { _askPrice = askPrice; }

    //public property for the ask price
    public object AskPrice { get { return _askPrice; } }

}//AskPriceChangedEventArgs

1
    /**********************Simple Example ***********************/    

class Program
        {
            static void Main(string[] args)
            {
                Parent p = new Parent();
            }
        }

        ////////////////////////////////////////////

        public delegate void DelegateName(string data);

        class Child
        {
            public event DelegateName delegateName;

            public void call()
            {
                delegateName("Narottam");
            }
        }

        ///////////////////////////////////////////

        class Parent
        {
            public Parent()
            {
                Child c = new Child();
                c.delegateName += new DelegateName(print);
                //or like this
                //c.delegateName += print;
                c.call();
            }

            public void print(string name)
            {
                Console.WriteLine("yes we got the name : " + name);
            }
        }

0

ソースコードを変更してオブザーバーを追加したくなかったので、次の簡単な例を記述しました。

//EVENT DRIVEN OBSERVER PATTERN
public class Publisher
{
    public Publisher()
    {
        var observable = new Observable();
        observable.PublishData("Hello World!");
    }
}

//Server will send data to this class's PublishData method
public class Observable
{
    public event Receive OnReceive;

    public void PublishData(string data)
    {
        //Add all the observer below
        //1st observer
        IObserver iObserver = new Observer1();
        this.OnReceive += iObserver.ReceiveData;
        //2nd observer
        IObserver iObserver2 = new Observer2();
        this.OnReceive += iObserver2.ReceiveData;

        //publish data 
        var handler = OnReceive;
        if (handler != null)
        {
            handler(data);
        }
    }
}

public interface IObserver
{
    void ReceiveData(string data);
}

//Observer example
public class Observer1 : IObserver
{
    public void ReceiveData(string data)
    {
        //sample observers does nothing with data :)
    }
}

public class Observer2 : IObserver
{
    public void ReceiveData(string data)
    {
        //sample observers does nothing with data :)
    }
}

0

このようなもの:

// interface implementation publisher
public delegate void eiSubjectEventHandler(eiSubject subject);

public interface eiSubject
{
    event eiSubjectEventHandler OnUpdate;

    void GenereteEventUpdate();

}

// class implementation publisher
class ecSubject : eiSubject
{
    private event eiSubjectEventHandler _OnUpdate = null;
    public event eiSubjectEventHandler OnUpdate
    {
        add
        {
            lock (this)
            {
                _OnUpdate -= value;
                _OnUpdate += value;
            }
        }
        remove { lock (this) { _OnUpdate -= value; } }
    }

    public void GenereteEventUpdate()
    {
        eiSubjectEventHandler handler = _OnUpdate;

        if (handler != null)
        {
            handler(this);
        }
    }

}

// interface implementation subscriber
public interface eiObserver
{
    void DoOnUpdate(eiSubject subject);

}

// class implementation subscriber
class ecObserver : eiObserver
{
    public virtual void DoOnUpdate(eiSubject subject)
    {
    }
}

イベントを伴うオブザーバーパターンC#リポジトリへのリンク

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.