ฉันเพิ่งเริ่มขุดคุ้ยภาษา C # แต่ฉันคิดไม่ออกว่าผู้ได้รับมอบหมายทำงานอย่างไรเมื่อใช้รูปแบบผู้สังเกตการณ์ / สังเกตได้ในภาษา
ใครช่วยยกตัวอย่างง่ายๆให้ฉันหน่อยได้ไหมว่ามันเสร็จแล้ว ฉันได้ googled สิ่งนี้แล้ว แต่ตัวอย่างทั้งหมดที่พบมีปัญหาเฉพาะเจาะจงเกินไปหรือ "ป่อง" เกินไป
คำตอบ:
รูปแบบการสังเกตการณ์มักจะถูกนำมาใช้กับเหตุการณ์ที่เกิดขึ้น
นี่คือตัวอย่าง:
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);
}
}
SomethingHappened = nullภายหลัง (วิธีที่สะดวกหากขี้เกียจและไม่เหมาะในการยกเลิกการสมัครตัวจัดการทั้งหมด) ดังนั้นการตรวจสอบค่าว่างจึงจำเป็นเสมอ
SomethingHappened?.Invoke(this, EventArgs.Empty);
นี่คือตัวอย่างง่ายๆ:
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;
}
}
บันทึก:
ในรูปแบบนี้คุณมีผู้เผยแพร่ที่จะใช้ตรรกะบางอย่างและเผยแพร่ "เหตุการณ์"
จากนั้นผู้เผยแพร่จะส่งกิจกรรมของตนให้เฉพาะสมาชิกที่สมัครรับข้อมูลเพื่อรับกิจกรรมที่ระบุ
ใน 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
}
}
เอาท์พุต:
ได้ยินโดยผู้ฟัง
ได้ยินโดย Listener2
ได้ยินโดยผู้ฟัง
ได้ยินโดย Listener2
ได้ยินโดยผู้ฟัง . . (ครั้งไม่มีที่สิ้นสุด)
ฉันได้รวบรวมตัวอย่างที่ยอดเยี่ยมสองสามตัวอย่างข้างต้นไว้ด้วยกัน (ขอบคุณเช่นเคยสำหรับMr. SkeetและMr.Karlsen ) เพื่อรวม Observables ที่แตกต่างกันสองสามแบบและใช้อินเทอร์เฟซเพื่อติดตามพวกเขาใน Observer และอนุญาตให้ Observer เพื่อ "สังเกต" Observables จำนวนเท่าใดก็ได้ผ่านรายการภายใน:
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 Patternกับผู้รับมอบสิทธิ์และเหตุการณ์ในc #มีชื่อว่า"Event Pattern"ตาม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
/**********************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);
}
}
ฉันไม่ต้องการเปลี่ยนซอร์สโค้ดเพื่อเพิ่มผู้สังเกตการณ์เพิ่มเติมดังนั้นฉันจึงเขียนตัวอย่างง่ายๆดังนี้
//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 :)
}
}
สิ่งนี้:
// 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 # กับเหตุการณ์ ลิงก์ไปยังที่เก็บ