majestio_event, C#

Language: Layout:

using System;
using System.Collections.Generic;
using System.Linq;
using Challenge.Interfaces;

//! Interfaces
namespace Challenge.Interfaces
{
    public interface IDecisionHandler
    {
        string HandleDecision(bool decision);
    }
	
    public interface IProcess
    {
        void Execute(List<int> values);
        bool Decision(List<int> values);
    }
}

namespace Challenge
{
//! DecisionhandlerContext
    public class DecisionHandlerContext
    {
        private Dictionary<string, IDecisionHandler> _handlers;
        public DecisionHandlerContext()
        {
            _handlers = new Dictionary<string, IDecisionHandler>();
        }

public void RegisterHandler(string processName, IDecisionHandler decisionHandler)
        {
            if (String.IsNullOrEmpty(processName) || decisionHandler == null)
                throw new Exception("Argument can't be null");

_handlers.Add(processName, decisionHandler);
        }

public string HandleDecisionAndGetNextStep(string processName, bool decision)
        {
            if (String.IsNullOrEmpty(processName))
                throw new Exception("Invalid arguments");

if(_handlers.TryGetValue(processName, out var handler))
            {
                return handler.HandleDecision(decision);
            }
            throw new Exception("Handle error");
        }
    }

public class Process1DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            if(decision)
                return Process4.ProcessName;
            return Process3.ProcessName;
        }
    }

public class Process2DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            if (decision)
                return Process3.ProcessName;
            return Process4.ProcessName;
        }
    }

public class Process3DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            if (decision)
                return Process2.ProcessName;
            return Process1.ProcessName;
        }
    }

public class Process4DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            if (decision)
                return Process5.ProcessName;
            return Process2.ProcessName;
        }
    }

public class Process5DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            return String.Empty;
        }
    }
	
//! Process1
    public class Process1 : IProcess
    {
        private const int MaxSizeValues = 4;
        public static string ProcessName => "1";

public void Execute(List<int> values)
        {
            if (values == null || values.Count > MaxSizeValues)
                throw new InvalidOperationException("List of values is empty...");
            ++values[0];
        }

public bool Decision(List<int> values)
        {
            return (values.Sum() % 2) == 0;
        }

}

//! Process2
    public class Process2 : IProcess
    {
        private const int MaxSizeValues = 4;
        public static string ProcessName => "2";

public bool Decision(List<int> values)
        {
            return (values.Sum() % 7) > 0;
        }

public void Execute(List<int> values)
        {
            if (values == null || values.Count > MaxSizeValues)
                throw new InvalidOperationException("List of values is empty...");

values[1] += values[3] + 1;
        }
    }

//! Process3
    public class Process3 : IProcess
    {
        private const int MaxSizeValues = 4;
        public static string ProcessName => "3";

public bool Decision(List<int> values)
        {
            var existOdd = values.Any(e => e % 2 != 0);
            return !existOdd;
        }

public void Execute(List<int> values)
        {
            if (values == null || values.Count > MaxSizeValues)
                throw new InvalidOperationException("List of values is empty...");

if ( (values[0] + values[1]) % 3 > 0 )
                values[2] += 7;
        }
    }

//! Process4
    public class Process4 : IProcess
    {
        private const int MaxSizeValues = 4;
        public static string ProcessName => "4";

public bool Decision(List<int> values)
        {
            return values.Sum() > 24;
        }

public void Execute(List<int> values)
        {
            if (values == null || values.Count > MaxSizeValues)
                throw new InvalidOperationException("List of values is empty...");

if ((values[0] + values[2]) % 5 != 4)
                ++values[3];
        }
    }

//! Process5
    public class Process5 : IProcess
    {
        public static string ProcessName => "5";

public bool Decision(List<int> values)
        {
            return true;
        }

public void Execute(List<int> values)
        {
        }
    }

//! ProcessContext
    public class ProcessContext
    {
        private Dictionary<string, IProcess> _processes;
        private DecisionHandlerContext _handlerContext;
        public ProcessContext()
        {
            _processes = new Dictionary<string, IProcess>();
            _handlerContext = new DecisionHandlerContext();
        }

public ProcessContext AddProcess(string proccesName, IProcess process, IDecisionHandler handler)
        {
            if (String.IsNullOrEmpty(proccesName) || process == null)
                throw new Exception("Argument can't be null");

_processes.Add(proccesName, process);
            _handlerContext.RegisterHandler(proccesName, handler);

return this;
        }

public bool RunProcessAndCheckDecision(string processName, List<int> values)
        {
            if(_processes.TryGetValue(processName, out var proc))
            {
                if (proc == null)
                    throw new Exception($"Process with name '{processName}' is null.");

proc.Execute(values);

return proc.Decision(values);
            }

throw new Exception($"Process with name '{processName}' not found.");
        }

public void RunAllProcesses(string startProcessName, List<int> values)
        {
            string currentProcessName = startProcessName;
            int step = 0;
            while (true)
            {
                Console.WriteLine($"Step {step}\t Proc: {currentProcessName}\t {String.Join(" ", values)}");

ProcessContext processContext = new ProcessContext();

processContext
                    .AddProcess(Process1.ProcessName, new Process1(), new Process1DecisionHandler())
                    .AddProcess(Process2.ProcessName, new Process2(), new Process2DecisionHandler())
                    .AddProcess(Process3.ProcessName, new Process3(), new Process3DecisionHandler())
                    .AddProcess(Process4.ProcessName, new Process4(), new Process4DecisionHandler())
                    .AddProcess(Process5.ProcessName, new Process5(), new Process5DecisionHandler());

processContext.RunAllProcesses(Process1.ProcessName, values);

Console.WriteLine("--------------------------");
                List<int> savedValues = new List<int> { 3, 3, 14, 1 };
                processContext.RunAllProcesses(Process4.ProcessName, savedValues);
            }
            catch(Exception error)
            {
                Console.WriteLine(error.Message);
            }
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0.71 sec, absolute running time: 0.22 sec, cpu time: 0.14 sec, memory peak: 39 Mb, absolute service time: 1 sec