Mediator Design Pattern

A.Mediator.Design.Pattern.cs

namespace Mediator
{
    class Program
    {
        /*
         * With the mediator pattern, communication between objects is encapsulated within a mediator object. Objects no longer communicate 
         * directly with each other, but instead communicate through the mediator. This reduces the dependencies between communicating objects, 
         * thereby reducing coupling.
         */
        static void Main(string[] args)
        {
            var serverMonitor = new ServerMonitor(new Mediator());

            serverMonitor.BeginMonitoring();
        }
    }
}

B.ServerMonitor.cs

namespace Mediator
{
    public class ServerMonitor
    {
        private readonly IMediator _mediator;

        public ServerMonitor(IMediator mediator) 
        {
            _mediator = mediator;
        }

        public void BeginMonitoring() 
        {
            Console.WriteLine("Monitoring the server now");

            Thread.Sleep(1000);

            Console.WriteLine("CPU Usage Threshold exceeded!");

            /*
             * Using the mediator pattern, the 'ServerMonitory' type has been decoupled from any handlers, and thus could send and 
             * retrieve data without having any dependencies except on the mediator.
             * 
             * For a more sophisticated implementation of the Mediator pattern, check the MediatR repository
             */

            _mediator.Send(new CpuThresholdExceeded
            {
                CpuLevel = 99,
                DetectedOn = DateTime.UtcNow
            });

            Console.WriteLine("CPU Spike Resuolved");

            Thread.Sleep(1000);

            Console.WriteLine("Memory Leak detected!");

            var memoryFreed = _mediator.Send(new MemoryThresholdExceeded
            {
                AvailableMemory = 3,
                DetectedOn = DateTime.UtcNow
            });

            Console.WriteLine($"{memoryFreed} GB Freed");
        }
    }
}

C.IMediator.cs

namespace Mediator
{
    public interface IMediator
    {
        void Send(CpuThresholdExceeded message);
        double Send(MemoryThresholdExceeded message);
    }
}

D.Mediator.cs

namespace Mediator
{
    /*
     * The mediator should merely act as a router which manages communication and shouldn't perform any logic
     */
    public class Mediator : IMediator
    {
        readonly CpuSpikeHandler _cpuSpikeHandler;

        readonly MemoryLeakHandler _memoryLeakHandler;

        public Mediator()
        {
            _cpuSpikeHandler = new CpuSpikeHandler();
            _memoryLeakHandler = new MemoryLeakHandler();
        }

        public void Send(CpuThresholdExceeded message) 
        {
            _cpuSpikeHandler.Handle(message);
        }

        public double Send(MemoryThresholdExceeded message)
        {
            return _memoryLeakHandler.Handle(message);
        }
    }
}

E.CpuThresholdExceeded.cs

namespace Mediator.Messages
{
    public class CpuThresholdExceeded
    {
        public int CpuLevel { get; set; }
        public DateTime DetectedOn { get; set; }
    }
}

F.MemoryThresholdExceeded.cs

namespace Mediator.Messages
{
    public class MemoryThresholdExceeded
    {
        public int AvailableMemory { get; set; }
        public DateTime DetectedOn { get; set; }
    }
}

G.CpuSpikeHandler.cs

namespace Mediator.Handlers
{
    public class CpuSpikeHandler
    {
        public void Handle(CpuThresholdExceeded arg)
        {
            Console.WriteLine("CPU Spike Handler Starting");
            Thread.Sleep(1000);
            Console.WriteLine("CPU Spike Handler Completed");
        }
    }
}

H.MemoryLeakHandler.cs

namespace Mediator.Handlers
{
    public class MemoryLeakHandler
    {

        public double Handle(MemoryThresholdExceeded arg)
        {
            Console.WriteLine("Memory Leak Handler Starting");
            Thread.Sleep(1000);
            Console.WriteLine("Memory Leak Handler Completed");
            return 12.8;
        }
    }
}