wound-v2, C# - rextester

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 Process5.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 Process6.ProcessName;
            return Process2.ProcessName;
        }
    }
    
    public class Process5DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            if(decision)
                return Process4.ProcessName;
            return Process3.ProcessName;
        }
    }

public class Process6DecisionHandler : IDecisionHandler
    {
        public string HandleDecision(bool decision)
        {
            return String.Empty;
        }
    }
	
//! Process1
    public class Process1 : IProcess
    {
        private const int MaxSizeValues = 5;
        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 = 5;
        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 = 5;
        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 = 5;
        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];
        }
    }

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

public bool Decision(List<int> values)
        {
            return values[4] > 0;
        }

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

++values[4];
        }
    }

//! Process6
    public class Process6 : IProcess
    {
        public static string ProcessName => "6";

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(int step, string startProcessName, List<int> values)
        {
            string currentProcessName = startProcessName;
            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())
                    .AddProcess(Process6.ProcessName, new Process6(), new Process6DecisionHandler());

processContext.RunAllProcesses(1, Process1.ProcessName, values);

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

Show compiler warnings [ + ] Show input
Compilation time: 1.13 sec, absolute running time: 0.32 sec, cpu time: 0.21 sec, memory peak: 39 Mb, absolute service time: 1,51 sec