90 lines
3.1 KiB
C#
90 lines
3.1 KiB
C#
using ObserverPattern.StockUpdateEvents;
|
|
using ObserverPattern.Twits;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace ObserverPattern
|
|
{
|
|
|
|
public class ObserverPatternExamples
|
|
{
|
|
public static void Run()
|
|
{
|
|
Console.WriteLine(GetDescription());
|
|
Console.WriteLine(GetActors());
|
|
Console.WriteLine(IsThisPubSub());
|
|
|
|
StockUpdateEventsExample stockExample = new StockUpdateEventsExample();
|
|
stockExample.RunSimple();
|
|
|
|
GoToNextStep();
|
|
|
|
Console.WriteLine(GetLapsedLinstenerProblem());
|
|
|
|
GoToNextStep();
|
|
|
|
Console.WriteLine("Same business logic using events combined with RX library");
|
|
stockExample.RunReactiveWithEvents();
|
|
|
|
GoToNextStep();
|
|
|
|
Console.WriteLine("Same business logic using RX library");
|
|
stockExample.RunReactive();
|
|
|
|
GoToNextStep();
|
|
|
|
ObservableTwitsExample obsTwits = new ObservableTwitsExample();
|
|
obsTwits.Run();
|
|
|
|
GoToNextStep();
|
|
}
|
|
|
|
private static string GetDescription()
|
|
{
|
|
return @"
|
|
The observer pattern is a software design pattern in which an object, called the subject,
|
|
maintains a list of its dependents, called observers, and notifies them automatically of any state changes,
|
|
usually by calling one of their methods. ";
|
|
}
|
|
|
|
private static string IsThisPubSub()
|
|
{
|
|
return @"
|
|
Observer/Observable pattern is mostly implemented in a synchronous way,
|
|
i.e. the observable calls the appropriate method of all its observers when some event occurs.
|
|
The Publisher/Subscriber pattern is mostly implemented in an asynchronous way (using message queue).
|
|
In the Observer/Observable pattern, the observers are aware of the observable.
|
|
Whereas, in Publisher/Subscriber, publishers and subscribers don't need to know each other.
|
|
They simply communicate with the help of message queues.
|
|
";
|
|
}
|
|
|
|
private static string GetActors()
|
|
{
|
|
return @"
|
|
Subject -> Interface/Abstract Notifies interested observers when an event occurs
|
|
Concrete Subject -> Implementation of Subject
|
|
Observer -> Interface/Abstract class -> Registers to a subject, to be notified when a specific event happens
|
|
Concrete Observer -> Implementation of the observer
|
|
";
|
|
}
|
|
|
|
private static string GetLapsedLinstenerProblem()
|
|
{
|
|
return @"
|
|
The leak happens when a listener fails to unsubscribe from the publisher when it no longer needs to listen.
|
|
Consequently, the publisher still holds a reference to the observer which prevents it from being garbage collected
|
|
— including all other objects it is referring to — for as long as the publisher is alive, which could be until the end of the application.
|
|
This causes not only a memory leak, but also a performance degradation with an 'uninterested' observer receiving and acting on unwanted events";
|
|
}
|
|
|
|
private static void GoToNextStep()
|
|
{
|
|
Console.ReadKey();
|
|
Console.Clear();
|
|
}
|
|
}
|
|
}
|