Суперпростий приклад спостерігача 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, щоб DoSomethingбезпечно реалізовувати обробку випадків SomethingHappened, на які не підписані, і тому є нульовим. Якщо ви використовуєте старішу версію C #, вам знадобиться такий код:

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

17
Щоб зберегти собі кілька рядків та уникнути нульової перевірки, ініціалізуйте подію так: stackoverflow.com/questions/340610/…
Dinah

1
@Dinah: Це не уникне нульової перевірки. Ви все одно можете встановити SomethingHappened = nullпізніше (зручний, якщо лінивий і неідеальний спосіб скасувати підписку на всі обробники), тому обов'язкова перевірка завжди необхідна.
Dan Puzey

4
@DanPuzey: Ви можете в межах класу, але однаково ви можете переконатися, що ви цього не робите - і інший код не може цього зробити, оскільки він може лише передплатити та скасувати підписку. Якщо ви переконуєтеся, що ніколи не встановлюєте його на нуль навмисно в межах вашого класу, добре уникати перевірки нуля.
Джон Скіт

2
@JonSkeet: звичайно, я забував, що ти не можеш цього робити поза класом. Вибачте!
Dan Puzey

2
Я думаю, ви можете замінити всі речі в DoSomething наSomethingHappened?.Invoke(this, EventArgs.Empty);
Junior Mayhé

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 зробити протилежний коду в конструкторі
  • Не виконується перевірка помилок, принаймні нульова перевірка не повинна проводитися в конструкторі 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

Я зв'язав разом декілька чудових прикладів вище (дякую, як завжди містеру Скіту та містерові Карлсену ), щоб включити пару різних Спостережних даних та застосував інтерфейс для відстеження їх у спостерігачі та дозволив спостерігачеві "спостерігати" за будь-якою кількістю спостережуваних даних через внутрішній список:

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 нульова перевірка повинна знаходитися всередині замка. Dispose також повинен мати замок і встановити прапорець DiSpised. Інакше хороший, повний приклад.
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 # з подією . посилання на сховище

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.