Added blackboard pattern demo

Author: Marcus Beranek

BlackBoardDemo/BlackBoardDemo.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30804.86
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BlackBoardDemo", "BlackBoardDemo\BlackBoardDemo.csproj", "{F2D444C7-69FF-46F3-BA5D-6A48558744E1}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BlackBoardDemoTests", "BlackBoardDemoTests\BlackBoardDemoTests.csproj", "{1F99C870-7849-4758-A7D5-343B87302E43}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F2D444C7-69FF-46F3-BA5D-6A48558744E1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2D444C7-69FF-46F3-BA5D-6A48558744E1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2D444C7-69FF-46F3-BA5D-6A48558744E1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2D444C7-69FF-46F3-BA5D-6A48558744E1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1F99C870-7849-4758-A7D5-343B87302E43}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1F99C870-7849-4758-A7D5-343B87302E43}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1F99C870-7849-4758-A7D5-343B87302E43}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1F99C870-7849-4758-A7D5-343B87302E43}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {CC4CB7D3-E156-4044-B38E-77014119C7EA}
+	EndGlobalSection
+EndGlobal

BlackBoardDemo/BlackBoardDemo/Analyzer.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace BlackBoardDemo
+{
+    public class Analyzer
+    {
+            public virtual ProblemState Analyze(Problem problem)
+            { throw new NotImplementedException(); }
+        
+    }
+}

BlackBoardDemo/BlackBoardDemo/Analyzers/SortAnalyser.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace BlackBoardDemo.Analyzers
+{
+    public class SortAnalyser : Analyzer
+    {
+        public override ProblemState Analyze(Problem problem)
+        {
+
+            var data = problem.Data as int[];
+
+            if (data == null)
+            {
+                return ProblemState.UnSolvable;
+            }
+            else if (data.Length == 0 || data.Length == 1)
+            {
+                return ProblemState.Solved;
+            }
+            else
+            {
+                for (var i = 0; i < data.Length - 1; i++)
+                {
+                    if (data[i] > data[i + 1])
+                    {
+                        return ProblemState.NeedsSorting;
+                    }
+                }
+
+                return ProblemState.Solved;
+            }
+        }
+    }
+}

BlackBoardDemo/BlackBoardDemo/BlackBoard.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BlackBoardDemo
+{
+    public class BlackBoard
+    {
+        public Problem InputProblem { get; set; }
+
+        public Problem CurrentSolution { get; set; }
+
+        public List<Problem> PartialSolutions { get; set; } = new List<Problem>();
+        public Analyzer ProblemAnalyzer { get; set; }
+
+        public void Analyze() 
+        {
+            if(CurrentSolution != null)
+            {
+                CurrentSolution.State = ProblemAnalyzer.Analyze(CurrentSolution);
+            }
+
+            foreach (var solutionPart in PartialSolutions)
+            {
+                if(solutionPart.State == ProblemState.Solved)
+                {
+                    solutionPart.State = ProblemAnalyzer.Analyze(solutionPart);
+                }
+            }
+        }
+    }
+}

BlackBoardDemo/BlackBoardDemo/BlackBoardDemo.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>

BlackBoardDemo/BlackBoardDemo/Controller.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Linq;
+
+namespace BlackBoardDemo
+{
+    public class Controller
+    {
+        private BlackBoard _blackBoard;
+        private KnowledgeBase _knowlegdeBase;
+        public Controller(BlackBoard board, KnowledgeBase kb)
+        {
+            _blackBoard = board;
+            _knowlegdeBase = kb;
+        }
+
+        public void Run()
+        {
+            if(!_blackBoard.PartialSolutions.Any())
+            {
+                _blackBoard.PartialSolutions.Insert(0,_blackBoard.InputProblem);
+            }
+
+            while(_blackBoard.PartialSolutions.Any( p => p.State != ProblemState.Solved))
+            {
+                var p = _blackBoard.PartialSolutions.First(p => p.State != ProblemState.Solved);
+                _blackBoard.PartialSolutions.Remove(p);
+
+                var solver = _knowlegdeBase.FindSolverFor(p);
+                var solutionParts = solver.Solve(p);
+                
+                _blackBoard.PartialSolutions.InsertRange(0,solutionParts);
+
+                _blackBoard.Analyze();
+            }
+
+            var result = new Problem() { Data = new int[0], State = ProblemState.Solved};
+            foreach(var part in _blackBoard.PartialSolutions)
+            {
+                var problem = new Problem()
+                {
+                    Data = new Tuple<Problem, Problem>(result, part),
+                    State = ProblemState.NeedsIntegration
+                };
+
+                var merger = _knowlegdeBase.FindSolverFor(problem);
+                result = merger.Solve(problem).Single();
+            }
+
+            _blackBoard.CurrentSolution = result;
+            _blackBoard.Analyze();
+        }
+    }
+}

BlackBoardDemo/BlackBoardDemo/EmptyProblemSolver.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace BlackBoardDemo
+{
+    public class EmptyProblemSolver : ProblemSolver
+    {
+        public EmptyProblemSolver()
+        {
+
+        }
+
+        public override bool CanSolve(Problem problem)
+        {
+            return false;
+        }
+
+        public override IEnumerable<Problem> Solve(Problem input)
+        {
+            return new[] { input };
+        }
+    }
+}

BlackBoardDemo/BlackBoardDemo/KnowledgeBase.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace BlackBoardDemo
+{
+    public class KnowledgeBase
+    {
+        public List<ProblemSolver> ProblemSolvers { get; set; } = new List<ProblemSolver>();
+
+        public ProblemSolver FindSolverFor(Problem input)
+        {
+            ProblemSolver foundSolver = null;
+            foreach (var solver in ProblemSolvers)
+            {
+                if (solver.CanSolve(input))
+                {
+                    foundSolver = solver;
+                }
+            }
+
+            return foundSolver;
+        }
+    }
+}

BlackBoardDemo/BlackBoardDemo/MergeSort.cs

@@ -0,0 +1,33 @@
+namespace BlackBoardDemo
+{
+    using Analyzers;
+    using System;
+
+    public class MergeSort
+    {
+        public int[] Sort(int[] input)
+        {
+            var problem = new Problem();
+            problem.State = ProblemState.NeedsSorting;
+            problem.Data = input;
+
+            // Push problem to a blackboard:
+            var blackBoard = new BlackBoard();
+            blackBoard.InputProblem = problem;
+            blackBoard.ProblemAnalyzer = new SortAnalyser();
+
+            // Set up a knoledgebase of all things, that we can do:
+            var kb = new KnowledgeBase();
+            kb.ProblemSolvers.Add(new Solvers.Splitter());
+            kb.ProblemSolvers.Add(new Solvers.Merger());
+            kb.ProblemSolvers.Add(new Solvers.Sorter());
+
+            // Add a controller to find a solution:
+            var controller = new Controller(blackBoard, kb);
+            controller.Run();
+
+            return blackBoard.CurrentSolution.Data as int[];
+        }
+    }
+}
+

BlackBoardDemo/BlackBoardDemo/Problem.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+
+namespace BlackBoardDemo
+{
+    public class Problem
+    {
+        public ProblemState State { get; set; }
+
+        public object Data { get; set; }
+
+    }
+}

BlackBoardDemo/BlackBoardDemo/ProblemSolver.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace BlackBoardDemo
+{
+    public class ProblemSolver
+    {
+        public static ProblemSolver Empty = new EmptyProblemSolver();
+        public virtual bool CanSolve(Problem input)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual IEnumerable<Problem> Solve(Problem input)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

BlackBoardDemo/BlackBoardDemo/ProblemState.cs

@@ -0,0 +1,7 @@
+using System;
+using System.Linq;
+
+namespace BlackBoardDemo
+{
+    public enum ProblemState { Solved, NeedsSorting, NeedsIntegration, TooBig, UnSolvable }
+}

BlackBoardDemo/BlackBoardDemo/Program.cs

@@ -0,0 +1,56 @@
+namespace BlackBoardDemo
+{
+    using System;
+    using Analyzers;
+
+    public class Program
+    {
+        static void Main(string[] args)
+        {
+            int length = 1000;
+            
+            if(args.Length > 0)
+            {
+                int cmdArg;
+
+                if(int.TryParse(args[0], out cmdArg))
+                {
+                    length = cmdArg;
+                }
+            }
+
+            Random rng = new Random((int)(DateTime.UtcNow.Ticks));
+            var input = new int[length];
+            for (int i = 0; i < length; i++)
+            {
+                input[i] = rng.Next();
+            }
+
+            var mergesort = new MergeSort();
+            var sorted = mergesort.Sort(input);
+
+            if (length <= 20)
+            {
+                Console.WriteLine("Input:");
+                for(int i = 0; i < length; i++)
+                {
+                    Console.WriteLine(input[i]);
+                }
+
+                Console.WriteLine();
+                Console.WriteLine("Sorted:");
+                for (int i = 0; i < length; i++)
+                {
+                    Console.WriteLine(sorted[i]);
+                }
+            }
+            else
+            {
+                Console.WriteLine($"Sorted {length} items");
+            }
+            
+            Console.ReadLine();
+        }
+    }
+}
+

BlackBoardDemo/BlackBoardDemo/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "BlackBoardDemo": {
+      "commandName": "Project",
+      "commandLineArgs": "20"
+    }
+  }
+}