using System;

using System.Collections.Generic;

using System.Threading;

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello World");

        MyObserverTest.run();

    }

     public class MyObserverTest

    {

        static Subject<Temprature> _sTempratureProvider = new();

        public static void run()

        {

            TempratureMonitor oT = new();

            using (var oTU = _sTempratureProvider.Subscribe(oT))

            {

                _sTempratureProvider.SetNext(new Temprature { Degrees = 11, Time = DateTime.Now, Stamp = "X" }); Thread.Sleep(1000);

                _sTempratureProvider.SetNext(new Temprature { Degrees = 15, Time = DateTime.Now, Stamp = "Y" }); Thread.Sleep(1000);

                _sTempratureProvider.SetNext(new Temprature { Degrees = 12, Time = DateTime.Now, Stamp = "Z" }); Thread.Sleep(1000);

            }

        }

    }

    /*

    public class Temprature : IDeepCloneable<Temprature>

    {

        public decimal Degrees { get; set; }

        public DateTime Time { get; set; }

        public string Stamp { get; set; }

        public Temprature DeepClone()

        {

            return new Temprature

            {

                Degrees = Degrees,

                Time = Time,

                Stamp = $"{Stamp}.cloned"

            };

        }

    }*/

     public record Temprature : IDeepCloneable<Temprature>

    {

        public decimal Degrees { get; init; }

        public DateTime Time { get; init; }

        public string Stamp { get; init; }

        public Temprature DeepClone()

        {

            return new Temprature

            {

                Degrees = Degrees,

                Time = Time,

                Stamp = $"{Stamp}.cloned"

            };

        }

    }

    internal class Unsubscriber<T> : IDisposable

    {

        private List<IObserver<T>> _observers;

        private IObserver<T> _observer;

        internal Unsubscriber(List<IObserver<T>> observers, IObserver<T> observer)

        {

            Console.WriteLine($"[Unsubscriber<T>.ctor] {typeof(T).Name}");

            this._observers = observers;

            this._observer = observer;

        }

        public void Dispose()

        {

            Console.WriteLine($"[Unsubscriber<T>.Dispose] {typeof(T).Name}");

            if (_observers.Contains(_observer))

            {

                _observers.Remove(_observer);

            }

        }

    }

    public interface IDeepCloneable<T> { T DeepClone();  }

    public class Subject<T> : IObservable<T>

        where T : IDeepCloneable<T>

    {

        private List<IObserver<T>> observers = new List<IObserver<T>>();

        public T LastTemprature { get; private set; }

        public IDisposable Subscribe(IObserver<T> observer)

        {

            // Check whether observer is already registered. If not, add it

            if (!observers.Contains(observer))

            {

                observers.Add(observer);

                // Provide observer with existing data.

                observer.OnNext(LastTemprature);

            }

            return new Unsubscriber<T>(observers, observer);

        }

        public void SetNext(T val)

        {

            LastTemprature = val.DeepClone();

            if (observers != null)

            {

                foreach (var observer in observers)

                {

                    observer.OnNext(LastTemprature);

                }

            }

        }

    }

    public class TempratureMonitor : IObserver<Temprature>

    {

        public void OnCompleted()

        {

            Console.WriteLine($"[TempratureMonitor.OnCompleted]");

        }

        public void OnError(Exception error)

        {

            Console.WriteLine($"[TempratureMonitor.OnError] {error}");

        }

        public void OnNext(Temprature value)

        {

            Console.WriteLine($"[TempratureMonitor.OnNext] {value?.ToString() ?? "null Val"}");

        }

    }

}

​