In diesem Artikel erfahren Sie mehr über das Observer Design Pattern in .NET C# mit einigen Verbesserungen.  Definition  des Beobachter-Entwurfsmusters  Das   ist eines der wichtigsten und am häufigsten verwendeten Design Patterns. Observer Design Pattern  Schauen wir uns zunächst die formale Definition des   an. Observer Design Pattern  Gemäß  :   Dokumentation von Microsoft   Das Beobachter-Entwurfsmuster ermöglicht es einem Abonnenten, sich bei einem Anbieter zu registrieren und Benachrichtigungen von ihm zu erhalten. Es eignet sich für jedes Szenario, das eine Push-basierte Benachrichtigung erfordert. Das Muster definiert einen Anbieter (auch bekannt als Subjekt oder Observable) und null, einen oder mehrere Beobachter. Beobachter registrieren sich beim Anbieter, und wenn eine vordefinierte Bedingung, ein vordefiniertes Ereignis oder eine Zustandsänderung eintritt, benachrichtigt der Anbieter automatisch alle Beobachter, indem er eine ihrer Methoden aufruft. In diesem Methodenaufruf kann der Anbieter Beobachtern auch aktuelle Zustandsinformationen zur Verfügung stellen. In .NET wird das Beobachterentwurfsmuster durch die Implementierung der generischen Schnittstellen   und   angewendet. Der generische Typparameter stellt den Typ dar, der Benachrichtigungsinformationen bereitstellt. System.IObservable<T> System.IObserver<T>  Aus der obigen Definition können wir also Folgendes verstehen:  Wir haben zwei Parteien bzw. Module.  Das Modul, das einen Informationsstrom bereitstellt. Dieses Modul heißt   (da es Informationen bereitstellt), oder   (da es Informationen an die Außenwelt weitergibt) oder   (da es von der Außenwelt beobachtet werden könnte). Provider Subject Observable  Das Modul, das an einem Informationsstrom interessiert ist, der von woanders kommt. Dieses Modul wird   genannt (da es Informationen beobachtet).  Observer  Vorteile des Observer Design Pattern  Wie wir jetzt wissen, formuliert das   die Beziehung zwischen den   und   Modulen. Das Besondere am   ist, dass Sie dies erreichen können, ohne eine eng gekoppelte Beziehung zu haben. Observer Design Pattern Observable- Observer- Observer Design Pattern   Wenn Sie die Funktionsweise des Musters analysieren, würden Sie Folgendes finden:  Das   kennt die minimal benötigten Informationen über den   . Observable Observer  Der   kennt die minimalen Informationen, die über das   benötigt werden. Observer Observable  Sogar die gegenseitige Kenntnis wird durch Abstraktionen erreicht, nicht durch konkrete Implementierungen.  Am Ende können beide Module ihren Job machen, und zwar nur ihren Job.   Verwendete Abstraktionen  Dies sind die   , die zur Implementierung des   in   verwendet werden. Abstraktionen Observer Design Pattern .NET C#  IObservable<out T>  Dies ist eine   Schnittstelle, die jedes   darstellt. Wenn Sie mehr über Varianz in .NET erfahren möchten, können Sie den Artikel lesen  . kovariante Observable   Kovarianz und Kontravarianz in .NET C#  In dieser Schnittstelle definierte Mitglieder sind:   public IDisposable Subscribe (IObserver<out T> observer);  Die   Methode sollte aufgerufen werden, um das   darüber zu informieren, dass ein   an seinem Informationsstrom interessiert ist. Subscribe Observable Observer  Die   Methode gibt ein Objekt zurück, das die   Schnittstelle implementiert. Dieses Objekt könnte dann vom   verwendet werden, um sich vom Informationsstrom abzumelden, der vom   bereitgestellt wird. Sobald dies erledigt ist, wird der   nicht über Aktualisierungen des Informationsstroms benachrichtigt. Subscribe IDisposable Observer Observable Beobachter  IObserver<in T>  Dies ist eine   Schnittstelle, die jeden   darstellt. Wenn Sie mehr über Varianz in .NET erfahren möchten, können Sie den Artikel lesen  . kontravariante Observer   Kovarianz und Kontravarianz in .NET C#  In dieser Schnittstelle definierte Mitglieder sind:   public void OnCompleted (); public void OnError (Exception error); public void OnNext (T value);  Die   Methode sollte vom   aufgerufen werden, um den   darüber zu informieren, dass der Informationsstrom abgeschlossen ist und der   keine weiteren Informationen erwarten sollte. OnCompleted Observable Observer Observer  Die   Methode sollte vom   aufgerufen werden, um den   darüber zu informieren, dass ein Fehler aufgetreten ist. OnError Observable Observer  Die   Methode sollte vom   aufgerufen werden, um den   darüber zu informieren, dass eine neue Information bereit ist und dem Stream hinzugefügt wird.  OnNext Observable Observer  Microsoft-Implementierung  Sehen wir uns nun an, wie   die Implementierung des   in C# empfiehlt. Später werde ich Ihnen einige kleinere Verbesserungen zeigen, die ich selbst implementiert habe. Microsoft Observer Design Pattern  Wir werden eine einfache   erstellen. In dieser Anwendung verfügen wir über das   Modul (Observable, Provider, Subject) und das   Modul (Observer). Wettervorhersage-Konsolenanwendung WeatherForecast- WeatherForecastObserver-  Beginnen wir also mit der Betrachtung der Implementierung.  WetterInfo   namespace Observable { public class WeatherInfo { internal WeatherInfo(double temperature) { Temperature = temperature; } public double Temperature { get; } } }  Dies ist die Entität, die die Information darstellt, die im Informationsstrom fließen soll.  Wettervorhersage   using System; using System.Collections.Generic; namespace Observable { public class WeatherForecast : IObservable<WeatherInfo> { private readonly List<IObserver<WeatherInfo>> m_Observers; private readonly List<WeatherInfo> m_WeatherInfoList; public WeatherForecast() { m_Observers = new List<IObserver<WeatherInfo>>(); m_WeatherInfoList = new List<WeatherInfo>(); } public IDisposable Subscribe(IObserver<WeatherInfo> observer) { if (!m_Observers.Contains(observer)) { m_Observers.Add(observer); foreach (var item in m_WeatherInfoList) { observer.OnNext(item); } } return new WeatherForecastUnsubscriber(m_Observers, observer); } public void RegisterWeatherInfo(WeatherInfo weatherInfo) { m_WeatherInfoList.Add(weatherInfo); foreach (var observer in m_Observers) { observer.OnNext(weatherInfo); } } public void ClearWeatherInfo() { m_WeatherInfoList.Clear(); } } }   Was wir hier bemerken können:  Die Klasse   implementiert   . WeatherForecast IObservable<WeatherInfo>  Bei der Implementierung der   Methode prüfen wir, ob der übergebene Observer bereits zuvor registriert wurde oder nicht. Wenn nicht, fügen wir es der lokalen   Beobachterliste hinzu. Dann durchlaufen wir nacheinander alle   Einträge in der lokalen   Liste und informieren den Observer darüber, indem wir die   Methode des Observers aufrufen. Subscribe m_Observers WeatherInfo m_WeatherInfoList OnNext  Schließlich geben wir eine neue Instanz der   Klasse zurück, die vom Observer zum Abbestellen des Informationsstroms verwendet wird. WeatherForecastUnsubscriber  Die   Methode ist so definiert, dass das Hauptmodul neue   registrieren kann. In der realen Welt könnte dies durch einen internen geplanten   oder einen Listener für einen   oder etwas anderes ersetzt werden, das als Informationsquelle fungiert. RegisterWeatherInfo WeatherInfo API-Aufruf SignalR-Hub  Abmelder<T>   using System; using System.Collections.Generic; namespace Observable { public class Unsubscriber<T> : IDisposable { private readonly List<IObserver<T>> m_Observers; private readonly IObserver<T> m_Observer; private bool m_IsDisposed; public Unsubscriber(List<IObserver<T>> observers, IObserver<T> observer) { m_Observers = observers; m_Observer = observer; } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (m_IsDisposed) return; if (disposing && m_Observers.Contains(m_Observer)) { m_Observers.Remove(m_Observer); } m_IsDisposed = true; } ~Unsubscriber() { Dispose(false); } } }   Was wir hier bemerken können:  Dies ist eine Basisklasse für jeden Un-Subscriber.  Es implementiert   durch Anwenden des   . IDisposable „Disposable Design Pattern“  Über den Konstruktor erhält es die vollständige Liste der Beobachter und des Beobachters, für den es erstellt wurde.  Beim Entsorgen wird geprüft, ob der Beobachter bereits in der vollständigen Liste der Beobachter vorhanden ist. Wenn ja, wird es aus der Liste entfernt.  WeatherForecastUnsubscriber   using System; using System.Collections.Generic; namespace Observable { public class WeatherForecastUnsubscriber : Unsubscriber<WeatherInfo> { public WeatherForecastUnsubscriber( List<IObserver<WeatherInfo>> observers, IObserver<WeatherInfo> observer) : base(observers, observer) { } } }   Was wir hier bemerken können:  Dies erbt von der   -Klasse. Unsubscriber<T>  Es findet keine besondere Behandlung statt.  WeatherForecastObserver   using System; namespace Observable { public class WeatherForecastObserver : IObserver<WeatherInfo> { private IDisposable m_Unsubscriber; public virtual void Subscribe(WeatherForecast provider) { m_Unsubscriber = provider.Subscribe(this); } public virtual void Unsubscribe() { m_Unsubscriber.Dispose(); } public void OnCompleted() { Console.WriteLine("Completed"); } public void OnError(Exception error) { Console.WriteLine("Error"); } public void OnNext(WeatherInfo value) { Console.WriteLine($"Temperature: {value.Temperature}"); } } }   Was wir hier bemerken können:  Die Klasse   implementiert   . WeatherForecastObserver IObserver<WeatherInfo>  Bei der   -Methode schreiben wir die Temperatur in die Konsole. OnNext  Bei der   Methode schreiben wir „Completed“ in die Konsole. OnCompleted  Bei der   Methode schreiben wir „Error“ in die Konsole. OnError  Wir haben die Methode   definiert, damit das Hauptmodul den Registrierungsprozess auslösen kann. Das zurückgegebene Abmeldeobjekt wird intern gespeichert, um im Falle einer Abmeldung verwendet zu werden. void Subscribe(WeatherForecast provider)  Mit dem gleichen Konzept wird die Methode   definiert und nutzt das intern gespeicherte Un-Subscriber-Objekt. void Unsubscribe()  Programm   using System; namespace Observable { class Program { static void Main(string[] args) { var provider = new WeatherForecast(); provider.RegisterWeatherInfo(new WeatherInfo(1)); provider.RegisterWeatherInfo(new WeatherInfo(2)); provider.RegisterWeatherInfo(new WeatherInfo(3)); var observer = new WeatherForecastObserver(); observer.Subscribe(provider); provider.RegisterWeatherInfo(new WeatherInfo(4)); provider.RegisterWeatherInfo(new WeatherInfo(5)); observer.Unsubscribe(); provider.RegisterWeatherInfo(new WeatherInfo(6)); observer.Subscribe(provider); provider.RegisterWeatherInfo(new WeatherInfo(7)); Console.ReadLine(); } } }   Was wir hier bemerken können:  Wir haben eine Instanz des Anbieters erstellt.  Dann wurden 3 Informationen registriert.  Bis zu diesem Zeitpunkt sollte nichts an der Konsole protokolliert werden, da keine Beobachter definiert sind.  Anschließend wurde eine Instanz des Beobachters erstellt.  Anschließend abonniert der Beobachter den Stream.  In diesem Moment sollten wir in der Konsole 3 protokollierte Temperaturen finden. Dies liegt daran, dass der Beobachter beim Abonnieren über die bereits vorhandenen Informationen benachrichtigt wird. In unserem Fall handelt es sich um drei Informationen.  Dann registrieren wir 2 Informationen.  Wir erhalten also zwei weitere Nachrichten, die in der Konsole protokolliert werden.  Dann melden wir uns ab.  Dann registrieren wir 1 Information.  Diese Information wurde jedoch nicht in der Konsole protokolliert, da sich der Beobachter bereits abgemeldet hatte.  Dann abonniert der Beobachter erneut.  Dann registrieren wir 1 Information.  Diese Informationen werden also in der Konsole protokolliert.  Abschließend sollte die Ausführung dieses Befehls zu diesem Ergebnis führen:   Meine erweiterte Implementierung  Als ich die Implementierung von Microsoft überprüfte, stieß ich auf einige Bedenken. Deshalb habe ich beschlossen, einige kleinere Änderungen vorzunehmen.  IExtendedObservable<out T>   using System; using System.Collections.Generic; namespace ExtendedObservable { public interface IExtendedObservable<out T> : IObservable<T> { IReadOnlyCollection<T> Snapshot { get; } IDisposable Subscribe(IObserver<T> observer, bool withHistory); } }   Was wir hier bemerken können:  Die   -Schnittstelle erweitert die   -Schnittstelle. IExtendedObservable<out T> IObservable<T>  Es ist   . Wenn Sie mehr darüber erfahren möchten, können Sie den Artikel lesen  . kovariant   Kovarianz und Kontravarianz in .NET C#  Wir haben   definiert, um anderen Modulen zu ermöglichen, sofort eine Liste bereits vorhandener Infoeinträge abzurufen, ohne sich anmelden zu müssen. IReadOnlyCollection<T> Snapshot  Wir haben auch die Methode   mit einem zusätzlichen   Parameter definiert, damit der Observer zum Zeitpunkt des Abonnements entscheiden kann, ob er über die bereits vorhandenen Infoeinträge benachrichtigt werden möchte oder nicht. IDisposable Subscribe(IObserver<T> observer, bool withHistory) bool withHistory  Abmelden   using System; namespace ExtendedObservable { public class Unsubscriber : IDisposable { private readonly Action m_UnsubscribeAction; private bool m_IsDisposed; public Unsubscriber(Action unsubscribeAction) { m_UnsubscribeAction = unsubscribeAction; } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (m_IsDisposed) return; if (disposing) { m_UnsubscribeAction(); } m_IsDisposed = true; } ~Unsubscriber() { Dispose(false); } } }   Was wir hier bemerken können:  Nun ist die   Klasse nicht generisch. Unsubscriber  Dies liegt daran, dass es nicht mehr erforderlich ist, den Typ der Info-Entität zu kennen.  Anstatt Zugriff auf die vollständige Liste der Beobachter und des Beobachters zu haben, für den es erstellt wurde, benachrichtigt es das Observable lediglich, wenn es entsorgt wird, und das Observable führt den Abmeldevorgang selbst durch.  Auf diese Weise leistet es weniger als zuvor und erledigt nur seine Aufgabe.  WeatherForecastUnsubscriber   using System; using System.Collections.Generic; namespace ExtendedObservable { public class WeatherForecastUnsubscriber : Unsubscriber { public WeatherForecastUnsubscriber( Action unsubscribeAction) : base(unsubscribeAction) { } } }   Was wir hier bemerken können:  Wir haben den Teil   aus   entfernt. <T> Unsubscriber<T>  Und jetzt übernimmt der Konstruktor eine   , die im Falle einer Entsorgung aufgerufen wird. Action  Wettervorhersage   using System; using System.Collections.Generic; namespace ExtendedObservable { public class WeatherForecast : IExtendedObservable<WeatherInfo> { private readonly List<IObserver<WeatherInfo>> m_Observers; private readonly List<WeatherInfo> m_WeatherInfoList; public WeatherForecast() { m_Observers = new List<IObserver<WeatherInfo>>(); m_WeatherInfoList = new List<WeatherInfo>(); } public IReadOnlyCollection<WeatherInfo> Snapshot => m_WeatherInfoList; public IDisposable Subscribe(IObserver<WeatherInfo> observer) { return Subscribe(observer, false); } public IDisposable Subscribe(IObserver<WeatherInfo> observer, bool withHistory) { if (!m_Observers.Contains(observer)) { m_Observers.Add(observer); if (withHistory) { foreach (var item in m_WeatherInfoList) { observer.OnNext(item); } } } return new WeatherForecastUnsubscriber( () => { if (m_Observers.Contains(observer)) { m_Observers.Remove(observer); } }); } public void RegisterWeatherInfo(WeatherInfo weatherInfo) { m_WeatherInfoList.Add(weatherInfo); foreach (var observer in m_Observers) { observer.OnNext(weatherInfo); } } public void ClearWeatherInfo() { m_WeatherInfoList.Clear(); } } }   Was wir hier bemerken können:  Es ist fast dasselbe, mit Ausnahme der   Eigenschaft, die die interne   Liste zurückgibt, jedoch als   . IReadOnlyCollection<WeatherInfo> Snapshot m_WeatherInfoList IReadOnlyCollection  Und die Methode   , die den Parameter   verwendet. IDisposable Subscribe(IObserver<WeatherInfo> observer, bool withHistory) withHistory  WeatherForecastObserver   using System; namespace ExtendedObservable { public class WeatherForecastObserver : IObserver<WeatherInfo> { private IDisposable m_Unsubscriber; public virtual void Subscribe(WeatherForecast provider) { m_Unsubscriber = provider.Subscribe(this, true); } public virtual void Unsubscribe() { m_Unsubscriber.Dispose(); } public void OnCompleted() { Console.WriteLine("Completed"); } public void OnError(Exception error) { Console.WriteLine("Error"); } public void OnNext(WeatherInfo value) { Console.WriteLine($"Temperature: {value.Temperature}"); } } }  Was wir hier bemerken können, ist, dass es fast dasselbe ist, mit Ausnahme von   , das nun entscheidet, ob ein   mit Verlauf erfolgen soll oder nicht. Subscribe(WeatherForecast provider) Subscribe  Programm   using System; namespace ExtendedObservable { class Program { static void Main(string[] args) { var provider = new WeatherForecast(); provider.RegisterWeatherInfo(new WeatherInfo(1)); provider.RegisterWeatherInfo(new WeatherInfo(2)); provider.RegisterWeatherInfo(new WeatherInfo(3)); var observer = new WeatherForecastObserver(); observer.Subscribe(provider); provider.RegisterWeatherInfo(new WeatherInfo(4)); provider.RegisterWeatherInfo(new WeatherInfo(5)); observer.Unsubscribe(); provider.RegisterWeatherInfo(new WeatherInfo(6)); observer.Subscribe(provider); provider.RegisterWeatherInfo(new WeatherInfo(7)); Console.ReadLine(); } } }  Es ist das Gleiche wie zuvor.  Abschließend sollte die Ausführung dieses Befehls zum gleichen Ergebnis wie zuvor führen:   Was kommt als nächstes  Jetzt kennen Sie die Grundlagen des   in .NET C#. Dies ist jedoch nicht das Ende der Geschichte. Observer Design Pattern  Es gibt Bibliotheken, die auf den Schnittstellen   und   aufbauen und weitere coole Features und Fähigkeiten bieten, die Sie möglicherweise nützlich finden. IObservable<T> IObserver<T>  Eine dieser Bibliotheken ist die  Bibliothek. Es besteht aus einer Reihe von Erweiterungsmethoden und LINQ-Standardsequenzoperatoren zur Unterstützung der asynchronen Programmierung.   Reaktive Erweiterungen für .NET (Rx)  Deshalb empfehle ich Ihnen, diese Bibliotheken zu erkunden und auszuprobieren. Ich bin mir sicher, dass Ihnen einige davon gefallen würden.   Auch  hier veröffentlicht.

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Check my links 😀

My HackerNoon Stories

My Medium Articles

Buy Me a Coffee

Buy Me a Gift

Check My Links

Hire Me

Dieses Audio ist in der Originalsprache der Geschichte produziert!

Ein wesentlicher Leitfaden zum Observer-Entwurfsmuster in .NET C#

About Author

KOMMENTARE

Hängeetiketten

DIESER ARTIKEL WURDE VORGESTELLT IN

Related Stories

HackerNoon Decoded 2024: Celebrating Our Life Hacking Community!

HackerNoon Decoded 2024: Celebrating Our AI Community!

HackerNoon Decoded 2024: Celebrating Our Programming Community!

HackerNoon Decoded 2024: Celebrating Our Cybersecurity Community!

HackerNoon Decoded 2024: Celebrating Our Life Hacking Community!

HackerNoon Decoded 2024: Celebrating Our AI Community!

HackerNoon Decoded 2024: Celebrating Our Programming Community!

HackerNoon Decoded 2024: Celebrating Our Cybersecurity Community!

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps