Bagikan melalui

Pola desain pengamat

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:

  • 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 pengamat, 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.

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);

Public Class BaggageInfo
    Private flightNo As Integer
    Private origin As String
    Private location As Integer

    Friend Sub New(ByVal flight As Integer, ByVal from As String, ByVal carousel As Integer)
        Me.flightNo = flight
        Me.origin = from
        Me.location = carousel
    End Sub

    Public ReadOnly Property FlightNumber As Integer
        Get
            Return Me.flightNo
        End Get
    End Property

    Public ReadOnly Property From As String
        Get
            Return Me.origin
        End Get
    End Property

    Public ReadOnly Property Carousel As Integer
        Get
            Return Me.location
        End Get
    End Property
End Class

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 HashSet<IObserver<BaggageInfo>> _observers = new();
    private readonly HashSet<BaggageInfo> _flights = new();

    public IDisposable Subscribe(IObserver<BaggageInfo> observer)
    {
        // Check whether observer is already registered. If not, add it.
        if (_observers.Add(observer))
        {
            // Provide observer with existing data.
            foreach (BaggageInfo item in _flights)
            {
                observer.OnNext(item);
            }
        }

        return new Unsubscriber<BaggageInfo>(_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);

        // Carousel is assigned, so add new info object to list.
        if (carousel > 0 && _flights.Add(info))
        {
            foreach (IObserver<BaggageInfo> observer in _observers)
            {
                observer.OnNext(info);
            }
        }
        else if (carousel is 0)
        {
            // Baggage claim for flight is done.
            if (_flights.RemoveWhere(
                flight => flight.FlightNumber == info.FlightNumber) > 0)
            {
                foreach (IObserver<BaggageInfo> observer in _observers)
                {
                    observer.OnNext(info);
                }
            }
        }
    }

    public void LastBaggageClaimed()
    {
        foreach (IObserver<BaggageInfo> observer in _observers)
        {
            observer.OnCompleted();
        }

        _observers.Clear();
    }
}

Public Class BaggageHandler : Implements IObservable(Of BaggageInfo)

    Private observers As List(Of IObserver(Of BaggageInfo))
    Private flights As List(Of BaggageInfo)

    Public Sub New()
        observers = New List(Of IObserver(Of BaggageInfo))
        flights = New List(Of BaggageInfo)
    End Sub

    Public Function Subscribe(ByVal observer As IObserver(Of BaggageInfo)) As IDisposable _
                    Implements IObservable(Of BaggageInfo).Subscribe
        ' Check whether observer is already registered. If not, add it
        If Not observers.Contains(observer) Then
            observers.Add(observer)
            ' Provide observer with existing data.
            For Each item In flights
                observer.OnNext(item)
            Next
        End If
        Return New Unsubscriber(Of BaggageInfo)(observers, observer)
    End Function

    ' Called to indicate all baggage is now unloaded.
    Public Sub BaggageStatus(ByVal flightNo As Integer)
        BaggageStatus(flightNo, String.Empty, 0)
    End Sub

    Public Sub BaggageStatus(ByVal flightNo As Integer, ByVal from As String, ByVal carousel As Integer)
        Dim info As New BaggageInfo(flightNo, from, carousel)

        ' Carousel is assigned, so add new info object to list.
        If carousel > 0 And Not flights.Contains(info) Then
            flights.Add(info)
            For Each observer In observers
                observer.OnNext(info)
            Next
        ElseIf carousel = 0 Then
            ' Baggage claim for flight is done
            Dim flightsToRemove As New List(Of BaggageInfo)
            For Each flight In flights
                If info.FlightNumber = flight.FlightNumber Then
                    flightsToRemove.Add(flight)
                    For Each observer In observers
                        observer.OnNext(info)
                    Next
                End If
            Next
            For Each flightToRemove In flightsToRemove
                flights.Remove(flightToRemove)
            Next
            flightsToRemove.Clear()
        End If
    End Sub

    Public Sub LastBaggageClaimed()
        For Each observer In observers
            observer.OnCompleted()
        Next
        observers.Clear()
    End Sub
End Class

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(Of BaggageInfo) ditampilkan dalam contoh berikut. Ketika kelas dibuat di dalam metode BaggageHandler.Subscribe, kelas diteruskan sebuah referensi ke koleksi _observers dan sebuah referensi ke seorang pengamat yang ditambahkan ke koleksi. Referensi ini ditetapkan ke variabel lokal. Ketika metode objek Dispose dipanggil, ia memeriksa apakah pengamat masih ada dalam _observers koleksi, dan, jika ya, menghapus pengamat.

namespace Observables.Example;

internal sealed class Unsubscriber<BaggageInfo> : IDisposable
{
    private readonly ISet<IObserver<BaggageInfo>> _observers;
    private readonly IObserver<BaggageInfo> _observer;

    internal Unsubscriber(
        ISet<IObserver<BaggageInfo>> observers,
        IObserver<BaggageInfo> observer) => (_observers, _observer) = (observers, observer);

    public void Dispose() => _observers.Remove(_observer);
}

Friend Class Unsubscriber(Of BaggageInfo) : Implements IDisposable
    Private _observers As List(Of IObserver(Of BaggageInfo))
    Private _observer As IObserver(Of BaggageInfo)

    Friend Sub New(ByVal observers As List(Of IObserver(Of BaggageInfo)), ByVal observer As IObserver(Of BaggageInfo))
        Me._observers = observers
        Me._observer = observer
    End Sub

    Public Sub Dispose() Implements IDisposable.Dispose
        If _observers.Contains(_observer) Then
            _observers.Remove(_observer)
        End If
    End Sub
End Class

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 List<string> _flights = new();
    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()
    {
        _cancellation?.Dispose();
        _flights.Clear();
    }

    public virtual void OnCompleted() => _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;

        // Flight has unloaded its baggage; remove from the monitor.
        if (info.Carousel is 0)
        {
            string flightNumber = string.Format("{0,5}", info.FlightNumber);
            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();
        }
    }
}

Public Class ArrivalsMonitor : Implements IObserver(Of BaggageInfo)
    Private name As String
    Private flightInfos As New List(Of String)
    Private cancellation As IDisposable
    Private fmt As String = "{0,-20} {1,5}  {2, 3}"

    Public Sub New(ByVal name As String)
        If String.IsNullOrEmpty(name) Then Throw New ArgumentNullException("The observer must be assigned a name.")

        Me.name = name
    End Sub

    Public Overridable Sub Subscribe(ByVal provider As BaggageHandler)
        cancellation = provider.Subscribe(Me)
    End Sub

    Public Overridable Sub Unsubscribe()
        cancellation.Dispose()
        flightInfos.Clear()
    End Sub

    Public Overridable Sub OnCompleted() Implements System.IObserver(Of BaggageInfo).OnCompleted
        flightInfos.Clear()
    End Sub

    ' No implementation needed: Method is not called by the BaggageHandler class.
    Public Overridable Sub OnError(ByVal e As System.Exception) Implements System.IObserver(Of BaggageInfo).OnError
        ' No implementation.
    End Sub

    ' Update information.
    Public Overridable Sub OnNext(ByVal info As BaggageInfo) Implements System.IObserver(Of BaggageInfo).OnNext
        Dim updated As Boolean = False

        ' Flight has unloaded its baggage; remove from the monitor.
        If info.Carousel = 0 Then
            Dim flightsToRemove As New List(Of String)
            Dim flightNo As String = String.Format("{0,5}", info.FlightNumber)
            For Each flightInfo In flightInfos
                If flightInfo.Substring(21, 5).Equals(flightNo) Then
                    flightsToRemove.Add(flightInfo)
                    updated = True
                End If
            Next
            For Each flightToRemove In flightsToRemove
                flightInfos.Remove(flightToRemove)
            Next
            flightsToRemove.Clear()
        Else
            ' Add flight if it does not exist in the collection.
            Dim flightInfo As String = String.Format(fmt, info.From, info.FlightNumber, info.Carousel)
            If Not flightInfos.Contains(flightInfo) Then
                flightInfos.Add(flightInfo)
                updated = True
            End If
        End If
        If updated Then
            flightInfos.Sort()
            Console.WriteLine("Arrivals information from {0}", Me.name)
            For Each flightInfo In flightInfos
                Console.WriteLine(flightInfo)
            Next
            Console.WriteLine()
        End If
    End Sub
End Class

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();

// Sample output:
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   Kalamazoo              712    3
//   
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   Kalamazoo              712    3
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   
//   Arrivals information from BaggageClaimMonitor1
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from SecurityExit
//   Detroit                712    3
//   Kalamazoo              712    3
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from BaggageClaimMonitor1
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from SecurityExit
//   New York-Kennedy       400    1
//   San Francisco          511    2
//   
//   Arrivals information from BaggageClaimMonitor1
//   San Francisco          511    2

Module Example
    Public Sub Main()
        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
' The example displays the following output:
'      Arrivals information from BaggageClaimMonitor1
'      Detroit                712    3
'
'      Arrivals information from BaggageClaimMonitor1
'      Detroit                712    3
'      Kalamazoo              712    3
'
'      Arrivals information from BaggageClaimMonitor1
'      Detroit                712    3
'      Kalamazoo              712    3
'      New York-Kennedy       400    1
'
'      Arrivals information from SecurityExit
'      Detroit                712    3
'
'      Arrivals information from SecurityExit
'      Detroit                712    3
'      Kalamazoo              712    3
'
'      Arrivals information from SecurityExit
'      Detroit                712    3
'      Kalamazoo              712    3
'      New York-Kennedy       400    1
'
'      Arrivals information from BaggageClaimMonitor1
'      Detroit                712    3
'      Kalamazoo              712    3
'      New York-Kennedy       400    1
'      San Francisco          511    2
'
'      Arrivals information from SecurityExit
'      Detroit                712    3
'      Kalamazoo              712    3
'      New York-Kennedy       400    1
'      San Francisco          511    2
'
'      Arrivals information from BaggageClaimMonitor1
'      New York-Kennedy       400    1
'      San Francisco          511    2
'
'      Arrivals information from SecurityExit
'      New York-Kennedy       400    1
'      San Francisco          511    2
'
'      Arrivals information from BaggageClaimMonitor1
'      San Francisco          511    2
Judul Deskripsi
Praktik Terbaik Pola Desain Pengamat Menjelaskan praktik terbaik untuk diadopsi saat mengembangkan aplikasi yang menerapkan pola desain pengamat.
Cara: Menerapkan Penyedia Menyediakan implementasi langkah demi langkah penyedia untuk aplikasi pemantauan suhu.
Cara: Mengimplementasikan Pengamat Menyediakan implementasi langkah demi langkah pengamat untuk aplikasi pemantauan suhu.
  • Last updated on