Catatan
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba masuk atau mengubah direktori.
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba mengubah direktori.
Pola desain pengamat memungkinkan pelanggan untuk mendaftar dan menerima pemberitahuan dari penyedia. Ini cocok untuk skenario apa pun yang memerlukan pemberitahuan berbasis push. Pola mendefinisikan penyedia (juga dikenal sebagai subjek atau dapat diamati) dan nol, satu, atau lebih pengamat. Pengamat mendaftar dengan penyedia, dan setiap kali kondisi, peristiwa, atau perubahan status yang telah ditentukan terjadi, penyedia secara otomatis memberi tahu semua pengamat dengan memanggil delegasi. Dalam panggilan metode ini, penyedia juga dapat memberikan informasi status saat ini kepada pengamat. Di .NET, pola desain observer diterapkan dengan mengimplementasikan antarmuka generik System.IObservable<T> dan System.IObserver<T>. Parameter jenis generik mewakili jenis yang menyediakan informasi pemberitahuan.
Kapan menerapkan pola
Pola desain pengamat cocok untuk pemberitahuan berbasis push terdistribusi, karena mendukung pemisahan yang bersih antara dua komponen atau lapisan aplikasi yang berbeda, seperti lapisan sumber data (logika bisnis) dan lapisan antarmuka pengguna (tampilan). Pola dapat diimplementasikan setiap kali penyedia menggunakan panggilan balik untuk menyediakan informasi saat ini kepada kliennya.
Menerapkan pola mengharuskan Anda memberikan detail berikut:
Penyedia atau subjek, yang merupakan objek yang mengirim pemberitahuan kepada pengamat. Penyedia adalah kelas atau struktur yang mengimplementasikan IObservable<T> antarmuka. Penyedia harus menerapkan satu metode, IObservable<T>.Subscribe, yang dipanggil oleh pengamat yang ingin menerima pemberitahuan dari penyedia.
Pengamat, yang merupakan objek yang menerima pemberitahuan dari penyedia. Pengamat adalah kelas atau struktur yang mengimplementasikan IObserver<T> antarmuka. Pengamat harus menerapkan tiga metode, yang semuanya dipanggil oleh penyedia:
- IObserver<T>.OnNext, yang menyediakan pengamat dengan informasi baru maupun informasi terkini.
- IObserver<T>.OnError, yang memberi tahu pengamat bahwa kesalahan telah terjadi.
- IObserver<T>.OnCompleted, yang menunjukkan bahwa penyedia telah selesai mengirim pemberitahuan.
Mekanisme yang memungkinkan penyedia untuk melacak pengamat. Biasanya, penyedia menggunakan objek kontainer, seperti System.Collections.Generic.List<T> objek, untuk menyimpan referensi ke IObserver<T> implementasi yang telah berlangganan pemberitahuan. Menggunakan wadah penyimpanan untuk tujuan ini memungkinkan penyedia menangani dari nol sampai jumlah pengamat yang tidak terbatas. Urutan di mana pengamat menerima pemberitahuan tidak ditentukan; penyedia bebas menggunakan metode apa pun untuk menentukan pesanan.
Implementasi IDisposable yang memungkinkan penyedia untuk menghapus pengamat saat pemberitahuan selesai. Pengamat menerima referensi ke IDisposable implementasi dari Subscribe metode , sehingga mereka juga dapat memanggil IDisposable.Dispose metode untuk berhenti berlangganan sebelum penyedia selesai mengirim pemberitahuan.
Objek yang berisi data yang dikirim penyedia ke pengamatnya. Jenis objek ini sesuai dengan parameter jenis generik antarmuka IObservable<T> dan IObserver<T> . Meskipun objek ini bisa sama dengan IObservable<T> implementasi, lebih sering ini adalah tipe yang terpisah.
Nota
Selain menerapkan pola desain observer, Anda mungkin tertarik untuk menjelajahi pustaka yang dibangun menggunakan antarmuka IObservable<T> dan IObserver<T>. Misalnya, Ekstensi Reaktif untuk .NET (Rx) terdiri dari serangkaian metode ekstensi dan operator urutan standar LINQ untuk mendukung pemrograman asinkron.
Kapan harus mempertimbangkan alternatif
Antarmuka />
- Event .NET standar — Untuk skenario notifikasi sederhana dalam satu aplikasi, event lebih lazim digunakan dan lebih mudah diimplementasikan.
-
IAsyncEnumerable<T>— Untuk urutan berbasis penarikan asinkron di mana konsumen mengontrol kecepatan, gunakan aliran asinkron. -
System.Threading.Channels— Untuk pola produsen-konsumen dengan dukungan backpressure dan asinkron, gunakan System.Threading.Channels. -
Reactive Extensions (Rx.NET) — Untuk komposisi, pemfilteran, dan transformasi peristiwa yang kompleks, gunakan paket
System.Reactivealih-alih menerapkanIObservable<T>secara langsung.
Pemanfaatan IObservable<T> yang paling menonjol dalam .NET adalah DiagnosticListener, yang memungkinkan pengembang framework dan pustaka menghasilkan event diagnostik terstruktur yang dapat dilanggani oleh konsumen.
Menerapkan pola
Contoh berikut menggunakan pola desain pengamat untuk menerapkan sistem informasi klaim bagasi bandara. Kelas BaggageInfo menyediakan informasi tentang penerbangan yang tiba dan konveyor bagasi tempat bagasi dari setiap penerbangan dapat diambil. Ini ditampilkan dalam contoh berikut.
namespace Observables.Example;
public readonly record struct BaggageInfo(
int FlightNumber,
string From,
int Carousel);
Namespace Example
Public Structure BaggageInfo
Implements IEquatable(Of BaggageInfo)
Public ReadOnly Property FlightNumber As Integer
Public ReadOnly Property From As String
Public ReadOnly Property Carousel As Integer
Public Sub New(flightNumber As Integer, from As String, carousel As Integer)
Me.FlightNumber = flightNumber
Me.From = from
Me.Carousel = carousel
End Sub
Public Overloads Function Equals(other As BaggageInfo) As Boolean Implements IEquatable(Of BaggageInfo).Equals
Return FlightNumber = other.FlightNumber AndAlso
From = other.From AndAlso
Carousel = other.Carousel
End Function
Public Overrides Function Equals(obj As Object) As Boolean
If TypeOf obj Is BaggageInfo Then
Return Equals(DirectCast(obj, BaggageInfo))
End If
Return False
End Function
Public Overrides Function GetHashCode() As Integer
Return HashCode.Combine(FlightNumber, From, Carousel)
End Function
Public Shared Operator =(left As BaggageInfo, right As BaggageInfo) As Boolean
Return left.Equals(right)
End Operator
Public Shared Operator <>(left As BaggageInfo, right As BaggageInfo) As Boolean
Return Not left.Equals(right)
End Operator
End Structure
End Namespace
Kelas BaggageHandler bertanggung jawab untuk menerima informasi tentang penerbangan yang tiba dan karosel pengambilan bagasi. Secara internal, ia mempertahankan dua koleksi:
-
_observers: Kumpulan klien yang mengamati informasi yang diperbarui. -
_flights: Kumpulan penerbangan dan carousel yang ditugaskan.
Kode sumber untuk BaggageHandler kelas ditampilkan dalam contoh berikut.
namespace Observables.Example;
public sealed class BaggageHandler : IObservable<BaggageInfo>
{
private readonly Lock _lock = new();
private readonly HashSet<IObserver<BaggageInfo>> _observers = [];
private readonly HashSet<BaggageInfo> _flights = [];
public IDisposable Subscribe(IObserver<BaggageInfo> observer)
{
BaggageInfo[] snapshot;
lock (_lock)
{
// Check whether observer is already registered. If not, add it.
if (!_observers.Add(observer))
{
return new Unsubscriber<BaggageInfo>(_lock, _observers, observer);
}
// Snapshot existing data while holding the lock.
snapshot = [.. _flights];
}
// Provide observer with existing data outside the lock.
foreach (BaggageInfo item in snapshot)
{
observer.OnNext(item);
}
return new Unsubscriber<BaggageInfo>(_lock, _observers, observer);
}
// Called to indicate all baggage is now unloaded.
public void BaggageStatus(int flightNumber) =>
BaggageStatus(flightNumber, string.Empty, 0);
public void BaggageStatus(int flightNumber, string from, int carousel)
{
var info = new BaggageInfo(flightNumber, from, carousel);
IObserver<BaggageInfo>[] snapshot;
// Carousel is assigned, so add new info object to list.
if (carousel > 0)
{
lock (_lock)
{
if (!_flights.Add(info))
{
return;
}
snapshot = [.. _observers];
}
foreach (IObserver<BaggageInfo> observer in snapshot)
{
observer.OnNext(info);
}
}
else if (carousel is 0)
{
// Baggage claim for flight is done.
lock (_lock)
{
if (_flights.RemoveWhere(
flight => flight.FlightNumber == info.FlightNumber) == 0)
{
return;
}
snapshot = [.. _observers];
}
foreach (IObserver<BaggageInfo> observer in snapshot)
{
observer.OnNext(info);
}
}
}
public void LastBaggageClaimed()
{
IObserver<BaggageInfo>[] snapshot;
lock (_lock)
{
snapshot = [.. _observers];
_observers.Clear();
}
foreach (IObserver<BaggageInfo> observer in snapshot)
{
observer.OnCompleted();
}
}
}
Namespace Example
Public NotInheritable Class BaggageHandler
Implements IObservable(Of BaggageInfo)
Private ReadOnly _lock As New Object()
Private ReadOnly _observers As New HashSet(Of IObserver(Of BaggageInfo))()
Private ReadOnly _flights As New HashSet(Of BaggageInfo)()
Public Function Subscribe(observer As IObserver(Of BaggageInfo)) As IDisposable Implements IObservable(Of BaggageInfo).Subscribe
Dim snapshot As BaggageInfo()
SyncLock _lock
' Check whether observer is already registered. If not, add it.
If Not _observers.Add(observer) Then
Return New Unsubscriber(Of BaggageInfo)(_lock, _observers, observer)
End If
' Snapshot existing data while holding the lock.
snapshot = _flights.ToArray()
End SyncLock
' Provide observer with existing data outside the lock.
For Each item As BaggageInfo In snapshot
observer.OnNext(item)
Next
Return New Unsubscriber(Of BaggageInfo)(_lock, _observers, observer)
End Function
' Called to indicate all baggage is now unloaded.
Public Sub BaggageStatus(flightNumber As Integer)
BaggageStatus(flightNumber, String.Empty, 0)
End Sub
Public Sub BaggageStatus(flightNumber As Integer, from As String, carousel As Integer)
Dim info As New BaggageInfo(flightNumber, from, carousel)
Dim snapshot As IObserver(Of BaggageInfo)()
' Carousel is assigned, so add new info object to list.
If carousel > 0 Then
SyncLock _lock
If Not _flights.Add(info) Then
Return
End If
snapshot = _observers.ToArray()
End SyncLock
For Each observer As IObserver(Of BaggageInfo) In snapshot
observer.OnNext(info)
Next
ElseIf carousel = 0 Then
' Baggage claim for flight is done.
SyncLock _lock
If _flights.RemoveWhere(
Function(flight) flight.FlightNumber = info.FlightNumber) = 0 Then
Return
End If
snapshot = _observers.ToArray()
End SyncLock
For Each observer As IObserver(Of BaggageInfo) In snapshot
observer.OnNext(info)
Next
End If
End Sub
Public Sub LastBaggageClaimed()
Dim snapshot As IObserver(Of BaggageInfo)()
SyncLock _lock
snapshot = _observers.ToArray()
_observers.Clear()
End SyncLock
For Each observer As IObserver(Of BaggageInfo) In snapshot
observer.OnCompleted()
Next
End Sub
End Class
End Namespace
Klien yang ingin menerima informasi yang diperbarui memanggil BaggageHandler.Subscribe metode . Jika klien sebelumnya belum berlangganan pemberitahuan, referensi ke implementasi klien IObserver<T> ditambahkan ke _observers koleksi.
Metode kelebihan BaggageHandler.BaggageStatus beban dapat dipanggil untuk menunjukkan bahwa bagasi dari penerbangan sedang dibongkar atau tidak lagi dibongkar. Dalam kasus pertama, metode ini diteruskan nomor penerbangan, bandara tempat penerbangan berasal, dan karusel tempat bagasi dibongkar. Dalam kasus kedua, metode hanya diteruskan nomor penerbangan. Untuk bagasi yang sedang dibongkar, metode memeriksa apakah informasi BaggageInfo yang diteruskan ke metode tersebut ada dalam koleksi _flights. Jika tidak, metode tersebut akan menambahkan informasi dan mengaktifkan metode dari setiap pengamat OnNext . Untuk penerbangan yang bagasinya tidak lagi dibongkar, metode memeriksa apakah informasi tentang penerbangan tersebut disimpan dalam _flights koleksi. Jika ya, metode memanggil metode setiap pengamat OnNext dan menghapus objek BaggageInfo dari koleksi _flights.
Ketika penerbangan terakhir hari itu telah mendarat dan bagasinya telah diproses, metode BaggageHandler.LastBaggageClaimed ini dipanggil. Metode ini memanggil metode OnCompleted setiap pengamat untuk menunjukkan bahwa semua pemberitahuan telah selesai, dan kemudian menghapus koleksi _observers.
Metode Subscribe dari penyedia mengembalikan implementasi IDisposable yang memungkinkan pengamat berhenti menerima pemberitahuan sebelum metode OnCompleted dipanggil. Kode sumber untuk kelas ini Unsubscriber ditampilkan dalam contoh berikut. Ketika kelas diinstansiasi dalam metode BaggageHandler.Subscribe, kelas tersebut diberi referensi ke objek _lock, koleksi _observers, dan referensi ke pengamat yang ditambahkan ke dalam koleksi tersebut. Referensi ini ditetapkan ke variabel lokal. Ketika metode Dispose milik objek dipanggil, metode tersebut menghapus pengamat dari koleksi _observers dalam kondisi terkunci.
namespace Observables.Example;
internal sealed class Unsubscriber<T> : IDisposable
{
private readonly Lock _lock;
private readonly ISet<IObserver<T>> _observers;
private readonly IObserver<T> _observer;
internal Unsubscriber(
Lock @lock,
ISet<IObserver<T>> observers,
IObserver<T> observer) => (_lock, _observers, _observer) = (@lock, observers, observer);
public void Dispose()
{
lock (_lock)
{
_observers.Remove(_observer);
}
}
}
Namespace Example
Friend NotInheritable Class Unsubscriber(Of T)
Implements IDisposable
Private ReadOnly _lock As Object
Private ReadOnly _observers As ISet(Of IObserver(Of T))
Private ReadOnly _observer As IObserver(Of T)
Friend Sub New(lock As Object, observers As ISet(Of IObserver(Of T)), observer As IObserver(Of T))
_lock = lock
_observers = observers
_observer = observer
End Sub
Public Sub Dispose() Implements IDisposable.Dispose
SyncLock _lock
_observers.Remove(_observer)
End SyncLock
End Sub
End Class
End Namespace
Contoh berikut menyediakan IObserver<T> implementasi bernama ArrivalsMonitor, yang merupakan kelas dasar yang menampilkan informasi klaim bagasi. Informasi ditampilkan menurut abjad, dengan nama kota asal. Metode ArrivalsMonitor ditandai sebagai overridable (dalam Visual Basic) atau virtual (dalam C#), sehingga dapat di-override dalam kelas turunan.
namespace Observables.Example;
public class ArrivalsMonitor : IObserver<BaggageInfo>
{
private readonly string _name;
private readonly Lock _lock = new();
private readonly List<string> _flights = [];
private readonly string _format = "{0,-20} {1,5} {2, 3}";
private IDisposable? _cancellation;
public ArrivalsMonitor(string name)
{
ArgumentException.ThrowIfNullOrEmpty(name);
_name = name;
}
public virtual void Subscribe(BaggageHandler provider) =>
_cancellation = provider.Subscribe(this);
public virtual void Unsubscribe()
{
Interlocked.Exchange(ref _cancellation, null)?.Dispose();
lock (_lock)
{
_flights.Clear();
}
}
public virtual void OnCompleted()
{
lock (_lock)
{
_flights.Clear();
}
}
// No implementation needed: Method is not called by the BaggageHandler class.
public virtual void OnError(Exception e)
{
// No implementation.
}
// Update information.
public virtual void OnNext(BaggageInfo info)
{
bool updated = false;
lock (_lock)
{
// Flight has unloaded its baggage; remove from the monitor.
if (info.Carousel is 0)
{
string flightNumber = $"{info.FlightNumber,5}";
for (int index = _flights.Count - 1; index >= 0; index--)
{
string flightInfo = _flights[index];
if (flightInfo.Substring(21, 5).Equals(flightNumber))
{
updated = true;
_flights.RemoveAt(index);
}
}
}
else
{
// Add flight if it doesn't exist in the collection.
string flightInfo = string.Format(_format, info.From, info.FlightNumber, info.Carousel);
if (_flights.Contains(flightInfo) is false)
{
_flights.Add(flightInfo);
updated = true;
}
}
if (updated)
{
_flights.Sort();
Console.WriteLine($"Arrivals information from {_name}");
foreach (string flightInfo in _flights)
{
Console.WriteLine(flightInfo);
}
Console.WriteLine();
}
}
}
}
Imports System.Threading
Namespace Example
Public Class ArrivalsMonitor
Implements IObserver(Of BaggageInfo)
Private ReadOnly _name As String
Private ReadOnly _lock As New Object()
Private ReadOnly _flights As New List(Of String)()
Private ReadOnly _format As String = "{0,-20} {1,5} {2, 3}"
Private _cancellation As IDisposable
Public Sub New(name As String)
If String.IsNullOrEmpty(name) Then
Throw New ArgumentException("Value cannot be null or empty.", NameOf(name))
End If
_name = name
End Sub
Public Overridable Sub Subscribe(provider As BaggageHandler)
_cancellation = provider.Subscribe(Me)
End Sub
Public Overridable Sub Unsubscribe()
Dim previous = Interlocked.Exchange(_cancellation, Nothing)
previous?.Dispose()
SyncLock _lock
_flights.Clear()
End SyncLock
End Sub
Public Overridable Sub OnCompleted() Implements IObserver(Of BaggageInfo).OnCompleted
SyncLock _lock
_flights.Clear()
End SyncLock
End Sub
' No implementation needed: Method is not called by the BaggageHandler class.
Public Overridable Sub OnError([error] As Exception) Implements IObserver(Of BaggageInfo).OnError
' No implementation.
End Sub
' Update information.
Public Overridable Sub OnNext(info As BaggageInfo) Implements IObserver(Of BaggageInfo).OnNext
Dim updated As Boolean = False
SyncLock _lock
' Flight has unloaded its baggage; remove from the monitor.
If info.Carousel = 0 Then
Dim flightNumber As String = String.Format("{0,5}", info.FlightNumber)
For index As Integer = _flights.Count - 1 To 0 Step -1
Dim flightInfo As String = _flights(index)
If flightInfo.Substring(21, 5).Equals(flightNumber) Then
updated = True
_flights.RemoveAt(index)
End If
Next
Else
' Add flight if it doesn't exist in the collection.
Dim flightInfo As String = String.Format(_format, info.From, info.FlightNumber, info.Carousel)
If Not _flights.Contains(flightInfo) Then
_flights.Add(flightInfo)
updated = True
End If
End If
If updated Then
_flights.Sort()
Console.WriteLine($"Arrivals information from {_name}")
For Each flightInfo As String In _flights
Console.WriteLine(flightInfo)
Next
Console.WriteLine()
End If
End SyncLock
End Sub
End Class
End Namespace
Kelas ArrivalsMonitor ini mencakup metode Subscribe dan Unsubscribe. Metode Subscribe ini memungkinkan kelas untuk menyimpan sebuah implementasi yang dikembalikan oleh panggilan IDisposable ke dalam variabel privat. Metode Unsubscribe ini memungkinkan kelas untuk berhenti berlangganan pemberitahuan dengan memanggil implementasi dari penyedia Dispose.
ArrivalsMonitor juga menyediakan implementasi OnNextmetode , OnError, dan OnCompleted . Hanya implementasi OnNext yang berisi sejumlah besar kode. Metode ini bekerja dengan objek privat, diurutkan, dan generik List<T> yang mempertahankan informasi tentang bandara asal untuk penerbangan yang tiba dan karosel di mana bagasi mereka tersedia. Jika kelas BaggageHandler melaporkan kedatangan penerbangan baru, implementasi metode OnNext akan menambahkan informasi tentang penerbangan tersebut ke dalam daftar. Jika BaggageHandler kelas melaporkan bahwa bagasi penerbangan telah dikeluarkan, metode OnNext akan menghapus penerbangan tersebut dari daftar. Setiap kali perubahan dilakukan, daftar diurutkan dan ditampilkan ke konsol.
Contoh berikut berisi titik masuk aplikasi yang membuat instans BaggageHandler kelas dan dua instans ArrivalsMonitor kelas, serta menggunakan metode BaggageHandler.BaggageStatus untuk menambahkan dan menghapus informasi tentang penerbangan yang tiba. Dalam setiap kasus, pengamat menerima pembaruan dan menampilkan informasi klaim bagasi dengan benar.
using Observables.Example;
BaggageHandler provider = new();
ArrivalsMonitor observer1 = new("BaggageClaimMonitor1");
ArrivalsMonitor observer2 = new("SecurityExit");
provider.BaggageStatus(712, "Detroit", 3);
observer1.Subscribe(provider);
provider.BaggageStatus(712, "Kalamazoo", 3);
provider.BaggageStatus(400, "New York-Kennedy", 1);
provider.BaggageStatus(712, "Detroit", 3);
observer2.Subscribe(provider);
provider.BaggageStatus(511, "San Francisco", 2);
provider.BaggageStatus(712);
observer2.Unsubscribe();
provider.BaggageStatus(400);
provider.LastBaggageClaimed();
Imports Observables.Example
Imports System.Threading
Module Program
Sub Main(args As String())
Dim provider As New BaggageHandler()
Dim observer1 As New ArrivalsMonitor("BaggageClaimMonitor1")
Dim observer2 As New ArrivalsMonitor("SecurityExit")
provider.BaggageStatus(712, "Detroit", 3)
observer1.Subscribe(provider)
provider.BaggageStatus(712, "Kalamazoo", 3)
provider.BaggageStatus(400, "New York-Kennedy", 1)
provider.BaggageStatus(712, "Detroit", 3)
observer2.Subscribe(provider)
provider.BaggageStatus(511, "San Francisco", 2)
provider.BaggageStatus(712)
observer2.Unsubscribe()
provider.BaggageStatus(400)
provider.LastBaggageClaimed()
End Sub
End Module
Konten terkait
Berkolaborasi dengan kami di GitHub
Sumber untuk konten ini dapat ditemukan di GitHub, yang juga dapat Anda gunakan untuk membuat dan meninjau masalah dan menarik permintaan. Untuk informasi selengkapnya, lihat panduan kontributor kami.
