using SimpleInjector;

using System;

​

namespace playground7jul

{

    class GraphModel

    {

        public string Name { get; set; }

    }

​

    interface ILogger

    {

        void Info(string message);

    }

​

    class Logger : ILogger

    {

        public void Info(string message)

        {

            Console.WriteLine("LOG.INFO: " + message);

        }

    }

​

    interface ICacheable<T>

    {

        T Get();

    }

​

    interface IGraphService : ICacheable<GraphModel>

    {

​

    }

​

    class GraphService : IGraphService

    {

        ILogger _logger;

        public GraphService(ILogger logger)

        {

            _logger = logger;

        }

​

        public GraphModel Get() {

            _logger.Info("GraphService.Get called.");

            return new GraphModel { Name = "Just a name.." };

        }

    }

​

    class Cache<T, V> where T : ICacheable<V>

    {

        T _service;

        ILogger _logger;

        IConfigurationService _configurationService;

​

        V _result;

        private int callTimes = 0;

​

        public Cache(

            T service,

            IConfigurationService configurationService,

            ILogger logger) {

            _service = service;

            _configurationService = configurationService;

            _logger = logger;

        }

​

        public V Get()

        {

            if (!_configurationService.GetIsCacheActivated())

            {

                return _service.Get();

            }

​

            if (callTimes == 0)

            {

                _result = _service.Get();

            }

            else

            {

                _logger.Info($"{_service.GetType()}.{nameof(_service.Get)} call already cached.");

            }

​

            callTimes++;

            return _result;

        }

    }

​

    interface IConfigurationService

    {

        bool GetIsCacheActivated();

    }

​

    class ConfigurationService : IConfigurationService

    {

        public bool GetIsCacheActivated() => true;

    }

    class GraphServiceCache : Cache<IGraphService, GraphModel>, IGraphService

    {

        public GraphServiceCache(

            GraphService service,

            IConfigurationService configurationService,

            ILogger logger

            ) : base(service, configurationService, logger) { }

    }

​

    interface IPrinter<T>

    {

        void Print(T arg);

    }

​

    class GraphPrinter : IPrinter<GraphModel>

    {

        public void Print(GraphModel arg)

        {

            Console.WriteLine(arg.Name);

        }

    }

​

    class MainApplication

    {

        GraphPrinter _graphPrinter;

        IGraphService _graphService;

​

        public MainApplication(

            IGraphService graphService,

            GraphPrinter graphPrinter)

        {

            _graphService = graphService;

            _graphPrinter = graphPrinter;

        }

​

        public void Work()

        {

            _graphPrinter.Print(_graphService.Get());

            _graphPrinter.Print(_graphService.Get());

        }

    }

​

    public class Program

    {

        private static Container InitContext()

        {

            // 1. Create a new Simple Injector container

            var container = new Container();

​

            // 2. Configure the container (register)

            container.Register<ILogger, Logger>();

            container.Register<IConfigurationService, ConfigurationService>();

            container.Register<IGraphService, GraphServiceCache>();

            container.Register<GraphPrinter>();

            container.Register<MainApplication>();

​

            // 3. Verify your configuration

            container.Verify();

​

            return container;

        }

​

        public static void Main(string[] args)

        {

            var container = InitContext();

​

            // 4. Use the container

            var myApp = container.GetInstance<MainApplication>();

​

            myApp.Work();

        }

    }

}

​