Program.cs

Go to the documentation of this file.

 
 
using System;
using System.Collections.Generic;
using System.Reflection;
 
namespace DesignPatternExamples_csharp
{
    class Program
    {
        //########################################################################
 
        struct Exercise
        {
            public string name;
 
            public Action exercise_to_run;
 
 
            public Exercise(string nameOfExercise, Action exercise)
            {
                name = nameOfExercise;
                exercise_to_run = exercise;
            }
        }
 
        internal struct Options
        {
            public List<string> exercise_names;
        }
 
        //########################################################################
 
        private string GetVersion()
        {
            string version = string.Empty;
            Version? asm_version = typeof(Program).Assembly.GetName().Version;
            if (asm_version != null)
            {
                version = asm_version.ToString();
            }
            return version;
        }
 
        private void Help(Exercise[] exercises)
        {
            string usage =
                "{0} (v{1}) by Stephen P. Lepisto\n" +
                "usage: {0} [--help][-?][options] [exercise_name][[ exercise_name][...]]\n" +
                "\n" +
                "Runs through a series of exercises showing off design patterns.  If no exercise_name\n" +
                "is given, then run through all exercises.\n" +
                "\n" +
                "Options:\n" +
                "--help, -?\n" +
                "     This help text.\n" +
                "--version\n" +
                "     Show just the version number of this application.\n" +
                "\n" +
                ""; // End of string.
 
            string appName = System.IO.Path.GetFileNameWithoutExtension(AppDomain.CurrentDomain.FriendlyName);
            Console.Write(usage, appName, GetVersion());
 
            Console.WriteLine("\nExercises available:");
            foreach (Exercise exercise in exercises)
            {
                Console.WriteLine("  {0}", exercise.name);
            }
        }
 
        private void ShowVersion()
        {
            Console.WriteLine(GetVersion());
        }
 
        bool ParseOptions(string[] args, Exercise[] exercises, ref Options options)
        {
            bool optionsValid = true;
 
            options.exercise_names = new List<string>();
 
            if (args.Length > 0)
            {
                foreach (string argument in args)
                {
                    string arg = argument;
                    if (string.Compare(arg, "--help") == 0 ||
                        string.Compare(arg, "-?") == 0 ||
                        string.Compare(arg, "/?") == 0)
                    {
                        Help(exercises);
                        optionsValid = false;
                        break;
                    }
                    else if (string.Compare(arg, "--version") == 0)
                    {
                        ShowVersion();
                        optionsValid = false;
                        break;
                    }
                    options.exercise_names.Add(arg);
                }
            }
 
            return optionsValid;
        }
 
 
        void Run(string[] args)
        {
            Exercise[] exercises = new Exercise[]
            {
                new Exercise("Adapter", () => { Adapter_Exercise exercise = new Adapter_Exercise(); exercise.Run(); }),
                new Exercise("Bridge", () => { Bridge_Exercise exercise = new Bridge_Exercise(); exercise.Run(); }),
                new Exercise("Command", () => { Command_Exercise exercise = new Command_Exercise(); exercise.Run(); }),
                new Exercise("Composite", () => { Composite_Exercise exercise = new Composite_Exercise(); exercise.Run(); }),
                new Exercise("Decorator", () => { Decorator_Exercise exercise = new Decorator_Exercise(); exercise.Run(); }),
                new Exercise("Facade", () => { Facade_Exercise exercise = new Facade_Exercise(); exercise.Run(); }),
                new Exercise("Flyweight", () => { Flyweight_Exercise exercise = new Flyweight_Exercise(); exercise.Run(); }),
                new Exercise("HandlerChain", () => { HandlerChain_Exercise exercise = new HandlerChain_Exercise(); exercise.Run(); }),
                new Exercise("Interpreter", () => { Interpreter_Exercise exercise = new Interpreter_Exercise(); exercise.Run(); }),
                new Exercise("Iterator", () => { Iterator_Exercise exercise = new Iterator_Exercise(); exercise.Run(); }),
                new Exercise("Mediator", () => { Mediator_Exercise exercise = new Mediator_Exercise(); exercise.Run(); }),
                new Exercise("Memento", () => { Memento_Exercise exercise = new Memento_Exercise(); exercise.Run(); }),
                new Exercise("NullObject", () => { NullObject_Exercise exercise = new NullObject_Exercise(); exercise.Run(); }),
                new Exercise("Observer", () => { Observer_Exercise exercise = new Observer_Exercise(); exercise.Run(); }),
                new Exercise("Proxy", () => { Proxy_Exercise exercise = new Proxy_Exercise(); exercise.Run(); }),
                new Exercise("State", () => { State_Exercise exercise = new State_Exercise(); exercise.Run(); }),
                new Exercise("Strategy", () => { Strategy_Exercise exercise = new Strategy_Exercise(); exercise.Run(); }),
                new Exercise("Visitor", () => { Visitor_Exercise exercise = new Visitor_Exercise(); exercise.Run(); }),
            };
 
            Options options = new Options();
            if (ParseOptions(args, exercises, ref options))
            {
                foreach (Exercise exercise in exercises)
                {
                    if (options.exercise_names.Count == 0 ||
                        options.exercise_names.FindIndex((string option_name) =>
                            String.Compare(option_name, exercise.name, true) == 0) != -1)
                    {
                        exercise.exercise_to_run();
                    }
                }
            }
        }
 
 
        //########################################################################
        //########################################################################
 
        static void Main(string[] args)
        {
            // Enable the virtual terminal processing mode for the life of this
            // program.
            using (EnableVTModeForWindowsConsole o = new EnableVTModeForWindowsConsole())
            {
                Program prog = new Program();
                prog.Run(args);
            }
        }
    }
}