Decoupled Messaging

gistfile1.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Reactive.Subjects;
using System.Threading.Tasks;

namespace DecoupledMessaging
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public async Task TestMethod1()
        {
            var temperatureDisplayer = new TemperatureDisplayer1();
            using (var temperaturePublisher = new TemperaturePublisher(temperatureDisplayer.DisplayTemperature))
            {
                await Task.Delay(5000);
            }
        }

        [TestMethod]
        public async Task TestMethod2()
        {
            var temperatureDisplayer = new TemperatureDisplayer2();
            using (var temperaturePublisher = new TemperaturePublisher(temperatureDisplayer.OnNext))
            {
                await Task.Delay(5000);
            }
        }

        [TestMethod]
        public async Task TestMethod3()
        {
            var subject = new Subject<double>();

            using (var temperatureDisplayer = new TemperatureDisplayer3(subject))
            {
                using (var temperaturePublisher = new TemperaturePublisher(subject.OnNext))
                {
                    await Task.Delay(5000);
                }
            }
        }
    }

    public delegate void SendTemperature(double temperature);

    public class TemperaturePublisher : IDisposable
    {
        private SendTemperature _sendTemperature;
        private bool _isRunning = true;

        public TemperaturePublisher(SendTemperature sendTemperature)
        {
            _sendTemperature = sendTemperature;
            Start();
        }

        private void Start()
        {
            Task.Run(async () =>
            {
                while (_isRunning)
                {
                    _sendTemperature(new Random().NextDouble() * 45);
                    await Task.Delay(1000);
                }
            });
        }

        public void Dispose()
        {
            _isRunning = false;
            _sendTemperature = null;
        }
    }

    public class TemperatureDisplayer1
    {
        public void DisplayTemperature(double temperature)
        {
            Console.WriteLine(temperature);
        }
    }

    public class TemperatureDisplayer2 : IObserver<double>
    {
        public void OnCompleted()
        {
        }

        public void OnError(Exception error)
        {
        }

        public void OnNext(double temperature)
        {
            Console.WriteLine(temperature);
        }
    }

    public class TemperatureDisplayer3 : IDisposable
    {
        private IDisposable _subscription;

        public TemperatureDisplayer3(IObservable<double> observable)
        {
            _subscription = observable.Subscribe((temperature) =>
            {
                Console.WriteLine(temperature);
            });
        }

        public void Dispose()
        {
            _subscription.Dispose();
        }
    }
}