Вывод результата, в зависимости от выбранных значений Combobox

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace EntityFrameworkCoreSample
{
    class Program
    {
        static void Main(string[] args)
        {
            var allLanguages = new List<Language>()
            {
                new Language("C#", "Object Oriented", "Strong", new [] { "Windows", "Linux", "Android", "iOS" }),
                new Language("Java", "Object Oriented", "Strong", new [] { "Windows", "Linux", "Android", "Embedded" }),
                new Language("F#", "Functional", "Strong", new [] { "Windows", "Linux", "Android", "iOS" }),
                new Language("Visual Basic", "Object Oriented", "Strong", new [] { "Windows", "Linux", "Android", "iOS" }),
                new Language("C", "Procedural", "Weak", new [] { "Windows", "Linux", "Android", "MacOS", "Embedded" }),
                new Language("Pascal", "Procedural", "Strong", new[] { "Windows", "Linux" }),
                new Language("Delphi", "Object Oriented", "Strong", new[] { "Windows" }),
            };
 
            ISelector<Language> languageExpertSystemRoot = 
                new LanguageParadigmSelector(allLanguages, 
                    paradigmFiltered => new LanguageTypizationSelector(paradigmFiltered, 
                        typizationFiltered => new NonRelevantQuestionWithRandomAnswer("Do you like bananas?", 
                            new LanguageTargetPlatformSelector(typizationFiltered.ToList(),
                                ltpFiltered => new FinalResult<Language>(ltpFiltered)),
                            new LanguageTargetPlatformSelector(typizationFiltered.ToList(),
                                ltpFiltered => new NonRelevantQuestionWithRandomAnswer("How about apples?", 
                                    new FinalResult<Language>(ltpFiltered)))
                    )));
 
            Dictionary<Type, Func<ISelector<Language>, ISelector<Language>>> dialogsFactory = new Dictionary<Type, Func<ISelector<Language>, ISelector<Language>>>
            {
                { typeof(LanguageParadigmSelector), input=> ConsoleDialog(input, "Select paradigm.") },
                { typeof(LanguageTypizationSelector), input=> ConsoleDialog(input, "Select typization.") },
                { typeof(LanguageTargetPlatformSelector), input=> ConsoleDialog(input, "Select target platform.") },
                { typeof(NonRelevantQuestionWithRandomAnswer), input=> ConsoleQuestionDialog((NonRelevantQuestionWithRandomAnswer)input) },
                { typeof(FinalResult<Language>), input=> ConsoleResultMessage((FinalResult<Language>)input) },
            };
 
            ISelector<Language> selector = languageExpertSystemRoot;
            do
            {
                var dialog = dialogsFactory[selector.GetType()];
                selector = dialog(selector);
            }
            while (selector!=null);
 
            Console.ReadKey();
        }
 
        private static ISelector<Language> ConsoleResultMessage(FinalResult<Language> input)
        {
            var results = input.Results.ToList();
            if (results.Count == 0)
            {
                Console.WriteLine("No results matched your choise.");
                return null;
            }
            Console.WriteLine("The results are:");
            foreach (var language in results)
            {
                Console.WriteLine(language.Name);
            }
            return null;
        }
 
        static ISelector<Language> ConsoleDialog(ISelector<Language> input, string description)
        {
            var choises = input.EnumerateChoises().ToList();
 
            if (choises.Count == 0)
            {
                return new FinalResult<Language>(Array.Empty<Language>());
            }
 
            Console.WriteLine(description);
 
            int num = 1;
            foreach (var choise in choises)
            {
                Console.WriteLine($"{num++}: {choise}");
            }
 
            int answer;
            while (!(int.TryParse(Console.ReadLine(), out answer) && answer >= 1 && answer <= choises.Count))
            {
                Console.WriteLine("Wrong input. Try again.");
            }
 
            string result = choises[answer - 1];
 
            return input.Select(result);
        }
 
        static ISelector<Language> ConsoleQuestionDialog(NonRelevantQuestionWithRandomAnswer input)
        {
            Console.WriteLine(input.Question);
            var answer = Console.ReadLine();
            return input.Select(answer);
        }
    }
 
    public class Language
    {
        public string Name { get; }
        public string Paradigm { get; }
        public string Typization { get; }
        public IReadOnlyCollection<string> TargetPlatforms { get; }
 
        public Language(string name, string paradigm, string typization, IReadOnlyCollection<string> targetPlatforms)
        {
            Name = name;
            Paradigm = paradigm;
            Typization = typization;
            TargetPlatforms = targetPlatforms;
        }
    }
 
    public interface ISelector<T>
    {
        ISelector<T> Select(string choise);
        IEnumerable<string> EnumerateChoises();
        IEnumerable<T> Results { get; }
    }
 
    public class DictionarySelector<T> : ISelector<T>
    {
        private IDictionary<string, ISelector<T>> _next = new Dictionary<string, ISelector<T>>();
        
        public ISelector<T> Select(string choise)
        {
            _next.TryGetValue(choise, out ISelector<T> next);
            return next;
        }
 
        public IEnumerable<string> EnumerateChoises()
        {
            return _next.Keys;
        }
 
        public IEnumerable<T> Results
        {
            get
            {
                foreach (var nextSelector in _next.Values)
                {
                    foreach (var result in nextSelector.Results)
                    {
                        yield return result;
                    }
                }
            }
        }
 
        public void Add(string choise, ISelector<T> selector)
        {
            _next.Add(choise, selector);
        }
    }
 
    public class ListSelector<T> : DictionarySelector<T>
    {
        public ListSelector(IReadOnlyCollection<T> list, Func<T, IEnumerable<string>> keysSelector, Func<IReadOnlyCollection<T>, ISelector<T>> innerSelectorFactory)
        {
            foreach (var group in list.SelectMany(x => keysSelector(x).Select(k => (k, x))).GroupBy(kv => kv.Item1))
            {
                Add(group.Key, innerSelectorFactory(group.Select(x => x.Item2).ToList()));
            }
        }
 
        public ListSelector(IEnumerable<T> list, Func<T, string> keySelector, Func<IReadOnlyCollection<T>, ISelector<T>> innerSelectorFactory)
        {
            foreach (var group in list.GroupBy(keySelector))
            {
                Add(group.Key, innerSelectorFactory(group.ToList()));
            }
        }
    }
 
    public class LanguageParadigmSelector : ListSelector<Language>
    {
        public LanguageParadigmSelector(IReadOnlyCollection<Language> list, Func<IReadOnlyCollection<Language>, ISelector<Language>> innerSelectorFactory) : base(list, x => x.Paradigm, innerSelectorFactory)
        {
        }
    }
 
    public class LanguageTypizationSelector : ListSelector<Language>
    {
        public LanguageTypizationSelector(IReadOnlyCollection<Language> list, Func<IReadOnlyCollection<Language>, ISelector<Language>> innerSelectorFactory) : base(list, x => x.Typization, innerSelectorFactory)
        {
        }
    }
 
    public class LanguageTargetPlatformSelector : ListSelector<Language>
    {
        public LanguageTargetPlatformSelector(IReadOnlyCollection<Language> list, Func<IReadOnlyCollection<Language>, ISelector<Language>> innerSelectorFactory) : base(list, x => x.TargetPlatforms, innerSelectorFactory)
        {
        }
    }
 
    public class NonRelevantQuestionWithRandomAnswer : ISelector<Language>
    {
        private readonly Random _random = new Random();
        private readonly IReadOnlyList<ISelector<Language>> _randomResults;
        public string Question { get; }
 
        public NonRelevantQuestionWithRandomAnswer(string question, params ISelector<Language>[] randomResults)
        {
            _randomResults = randomResults;
            Question = question;
        }
 
        public ISelector<Language> Select(string choise)
        {
            var result = _random.Next(0, _randomResults.Count);
            return _randomResults[result];
        }
 
        public IEnumerable<string> EnumerateChoises()
        {
            yield break;
        }
 
        public IEnumerable<Language> Results
        {
            get
            {
                foreach (var answer in _randomResults)
                {
                    foreach (var result in answer.Results)
                    {
                        yield return result;
                    }
                }
            }
        }
    }
 
    public class FinalResult<T> : ISelector<T>
    {
        public FinalResult(IEnumerable<T> results)
        {
            Results = results;
        }
 
        public ISelector<T> Select(string choise)
        {
            throw new InvalidOperationException();
        }
 
        public IEnumerable<string> EnumerateChoises()
        {
            yield break;
        }
 
        public IEnumerable<T> Results { get; }
    }
}