diff --git a/.gitignore b/.gitignore
index 176c449..f848412 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,4 +26,5 @@ obj/
 _ReSharper*/
 [Tt]est[Rr]esult*
 *.vssscc
-$tf*/
\ No newline at end of file
+$tf*/
+.vs/
diff --git a/ConsoleApplicationBase.sln b/ConsoleApplicationBase.sln
index 2cedf79..1763b1a 100644
--- a/ConsoleApplicationBase.sln
+++ b/ConsoleApplicationBase.sln
@@ -1,10 +1,12 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2013
-VisualStudioVersion = 12.0.30723.0
+# Visual Studio 15
+VisualStudioVersion = 15.0.26403.7
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApplicationBase", "ConsoleApplicationBase\ConsoleApplicationBase.csproj", "{D21CC334-9E7D-4A29-B6F9-5120351EC703}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestLib", "TestLib\TestLib.csproj", "{2304B2F5-905D-46CD-9BC1-F10973FBEDC4}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{D21CC334-9E7D-4A29-B6F9-5120351EC703}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D21CC334-9E7D-4A29-B6F9-5120351EC703}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D21CC334-9E7D-4A29-B6F9-5120351EC703}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2304B2F5-905D-46CD-9BC1-F10973FBEDC4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2304B2F5-905D-46CD-9BC1-F10973FBEDC4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2304B2F5-905D-46CD-9BC1-F10973FBEDC4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2304B2F5-905D-46CD-9BC1-F10973FBEDC4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/ConsoleApplicationBase/App.config b/ConsoleApplicationBase/App.config
index 8e15646..73313cb 100644
--- a/ConsoleApplicationBase/App.config
+++ b/ConsoleApplicationBase/App.config
@@ -1,6 +1,23 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <configuration>
+    <configSections>
+        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
+            <section name="ConsoleApplicationBase.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
+        </sectionGroup>
+    </configSections>
     <startup> 
         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
     </startup>
+<userSettings>
+        <ConsoleApplicationBase.Properties.Settings>
+                <setting name="AssemblyFiles" serializeAs="Xml">
+                        <value>
+                                <ArrayOfString xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                                        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+                                        <string>..\..\..\TestLib\bin\Debug\TestLib.dll</string>
+                                </ArrayOfString>
+                        </value>
+                </setting>
+        </ConsoleApplicationBase.Properties.Settings>
+    </userSettings>
 </configuration>
\ No newline at end of file
diff --git a/ConsoleApplicationBase/AppState.cs b/ConsoleApplicationBase/AppState.cs
new file mode 100644
index 0000000..c1eb3a0
--- /dev/null
+++ b/ConsoleApplicationBase/AppState.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleApplicationBase
+{
+    public static class AppState
+    {
+        static State _state;
+
+        static AppState()
+        {
+            _state = State.IDLE;
+        }
+
+        public static State GetState()
+        {
+            return _state;
+        }
+
+        public static void SetState(State newState)
+        {
+            _state = newState;
+        }
+
+    }
+
+    public enum State
+    {
+        ERROR = -1,
+        IDLE = 0,
+        RUNNING = 1
+    }
+}
diff --git a/ConsoleApplicationBase/CommandClassInfo.cs b/ConsoleApplicationBase/CommandClassInfo.cs
new file mode 100644
index 0000000..85fef97
--- /dev/null
+++ b/ConsoleApplicationBase/CommandClassInfo.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleApplicationBase
+{
+    public class CommandClassInfo
+    {
+        public Assembly OwningAssembly { get; }
+        public Dictionary<string, IEnumerable<ParameterInfo>> MethodDictionary { get; }
+
+        public CommandClassInfo(Assembly owningAssembly, Dictionary<string, IEnumerable<ParameterInfo>> methodDict)
+        {
+            this.OwningAssembly = owningAssembly;
+            this.MethodDictionary = methodDict;
+        }
+    }
+}
diff --git a/ConsoleApplicationBase/CommandHandler.cs b/ConsoleApplicationBase/CommandHandler.cs
new file mode 100644
index 0000000..2d878b3
--- /dev/null
+++ b/ConsoleApplicationBase/CommandHandler.cs
@@ -0,0 +1,303 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleApplicationBase
+{
+    public static class CommandHandler
+    {
+        //static List<object> methodParameterValueList = new List<object>();
+        //static IEnumerable<ParameterInfo> paramInfoList;
+
+        public static string Execute(ConsoleCommand command2Execute)
+        {
+            // Validate the class name and command name:
+            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+            string badCommandMessage = string.Format(""
+                + "Unrecognized command \'{0}.{1}\'. "
+                + "Please type a valid command.",
+                command2Execute.LibraryClassName, command2Execute.Name);
+
+            // Validate the command name:
+            if (!CommandLibrary.Content.ContainsKey(command2Execute.LibraryClassName))
+            {
+                return badCommandMessage;
+            }
+            
+            var commandClassInfo = CommandLibrary.Content[command2Execute.LibraryClassName];
+            if (!commandClassInfo.MethodDictionary.ContainsKey(command2Execute.Name))
+            {
+                return badCommandMessage;
+            }
+
+            // Make sure the corret number of required arguments are provided:
+            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+            var methodParameterValueList = new List<object>();
+            IEnumerable<ParameterInfo> paramInfoList = commandClassInfo.MethodDictionary[command2Execute.Name].ToList();
+
+            // Validate proper # of required arguments provided. Some may be optional:
+            var requiredParams = paramInfoList.Where(p => p.IsOptional == false);
+            var optionalParams = paramInfoList.Where(p => p.IsOptional == true);
+            int requiredCount = requiredParams.Count();
+            int optionalCount = optionalParams.Count();
+            int providedCount = command2Execute.Arguments.Count();
+
+            if (requiredCount > providedCount)
+            {
+                return string.Format(
+                    "Missing required argument. {0} required, {1} optional, {2} provided",
+                    requiredCount, optionalCount, providedCount);
+            }
+
+            // Make sure all arguments are coerced to the proper type, and that there is a 
+            // value for every emthod parameter. The InvokeMember method fails if the number 
+            // of arguments provided does not match the number of parameters in the 
+            // method signature, even if some are optional:
+            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+            if (paramInfoList.Count() > 0)
+            {
+                // Populate the list with default values:
+                foreach (var param in paramInfoList)
+                {
+                    // This will either add a null object reference if the param is required 
+                    // by the method, or will set a default value for optional parameters. in 
+                    // any case, there will be a value or null for each method argument 
+                    // in the method signature:
+                    methodParameterValueList.Add(param.DefaultValue);
+                }
+
+                // Now walk through all the arguments passed from the console and assign 
+                // accordingly. Any optional arguments not provided have already been set to 
+                // the default specified by the method signature:
+                for (int i = 0; i < command2Execute.Arguments.Count(); i++)
+                {
+                    var methodParam = paramInfoList.ElementAt(i);
+                    var typeRequired = methodParam.ParameterType;
+                    object value = null;
+                    try
+                    {
+                        // Coming from the Console, all of our arguments are passed in as 
+                        // strings. Coerce to the type to match the method paramter:
+                        value = CoerceArgument(typeRequired, command2Execute.Arguments.ElementAt(i));
+                        methodParameterValueList.RemoveAt(i);
+                        methodParameterValueList.Insert(i, value);
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        string argumentName = methodParam.Name;
+                        string argumentTypeName = typeRequired.Name;
+                        string message =
+                            string.Format(""
+                            + "The value passed for argument '{0}' cannot be parsed to type '{1}'",
+                            argumentName, argumentTypeName);
+                        throw new ArgumentException(message);
+                    }
+                }
+            }
+
+            // Set up to invoke the method using reflection:
+            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+            Assembly current = commandClassInfo.OwningAssembly; //typeof(Program).Assembly;
+
+            // Need the full Namespace for this:
+            Type commandLibaryClass =
+                current.GetType(CommandLibrary.CommandNamespace + "." + command2Execute.LibraryClassName);
+
+            object[] inputArgs = null;
+            if (methodParameterValueList.Count > 0)
+            {
+                inputArgs = methodParameterValueList.ToArray();
+            }
+            var typeInfo = commandLibaryClass;
+
+            // This will throw if the number of arguments provided does not match the number 
+            // required by the method signature, even if some are optional:
+            try
+            {
+                var result = typeInfo.InvokeMember(
+                    command2Execute.Name,
+                    BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public,
+                    null, null, inputArgs);
+                return result.ToString();
+            }
+            catch (TargetInvocationException ex)
+            {
+                throw ex.InnerException;
+            }
+        }
+
+        static object CoerceArgument(Type requiredType, string inputValue)
+        {
+            var requiredTypeCode = Type.GetTypeCode(requiredType);
+            string exceptionMessage =
+                string.Format("Cannnot coerce the input argument {0} to required type {1}",
+                inputValue, requiredType.Name);
+
+            object result = null;
+            switch (requiredTypeCode)
+            {
+                case TypeCode.String:
+                    result = inputValue;
+                    break;
+
+                case TypeCode.Int16:
+                    short number16;
+                    if (Int16.TryParse(inputValue, out number16))
+                    {
+                        result = number16;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+
+                case TypeCode.Int32:
+                    int number32;
+                    if (Int32.TryParse(inputValue, out number32))
+                    {
+                        result = number32;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+
+                case TypeCode.Int64:
+                    long number64;
+                    if (Int64.TryParse(inputValue, out number64))
+                    {
+                        result = number64;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+
+                case TypeCode.Boolean:
+                    bool trueFalse;
+                    if (bool.TryParse(inputValue, out trueFalse))
+                    {
+                        result = trueFalse;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+
+                case TypeCode.Byte:
+                    byte byteValue;
+                    if (byte.TryParse(inputValue, out byteValue))
+                    {
+                        result = byteValue;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+
+                case TypeCode.Char:
+                    char charValue;
+                    if (char.TryParse(inputValue, out charValue))
+                    {
+                        result = charValue;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+
+                case TypeCode.DateTime:
+                    DateTime dateValue;
+                    if (DateTime.TryParse(inputValue, out dateValue))
+                    {
+                        result = dateValue;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                case TypeCode.Decimal:
+                    Decimal decimalValue;
+                    if (Decimal.TryParse(inputValue, out decimalValue))
+                    {
+                        result = decimalValue;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                case TypeCode.Double:
+                    Double doubleValue;
+                    if (Double.TryParse(inputValue, out doubleValue))
+                    {
+                        result = doubleValue;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                case TypeCode.Single:
+                    Single singleValue;
+                    if (Single.TryParse(inputValue, out singleValue))
+                    {
+                        result = singleValue;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                case TypeCode.UInt16:
+                    UInt16 uInt16Value;
+                    if (UInt16.TryParse(inputValue, out uInt16Value))
+                    {
+                        result = uInt16Value;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                case TypeCode.UInt32:
+                    UInt32 uInt32Value;
+                    if (UInt32.TryParse(inputValue, out uInt32Value))
+                    {
+                        result = uInt32Value;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                case TypeCode.UInt64:
+                    UInt64 uInt64Value;
+                    if (UInt64.TryParse(inputValue, out uInt64Value))
+                    {
+                        result = uInt64Value;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(exceptionMessage);
+                    }
+                    break;
+                default:
+                    throw new ArgumentException(exceptionMessage);
+            }
+            return result;
+        }
+    }
+}
diff --git a/ConsoleApplicationBase/CommandLibrary.cs b/ConsoleApplicationBase/CommandLibrary.cs
new file mode 100644
index 0000000..bf7b245
--- /dev/null
+++ b/ConsoleApplicationBase/CommandLibrary.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using ConsoleApplicationBase.Properties;
+
+namespace ConsoleApplicationBase
+{
+    public static class CommandLibrary
+    {
+        public static readonly string CommandNamespace = "ConsoleApplicationBase.Commands";
+        public static Dictionary<string, CommandClassInfo> Content { get; }
+
+
+        static CommandLibrary()
+        {
+            Content = new Dictionary<string, CommandClassInfo>();
+            initialize();
+        }
+
+
+        static void initialize()
+        {
+            var assembly = Assembly.GetExecutingAssembly();
+            var commandClasses = listMatchingAssemblyTypes(assembly);
+
+            //add commands defined inside DefaultCommands
+            addCommands(assembly, commandClasses);
+
+            //add commands from external assemblies listed in App.config
+            foreach (var assemblyFile in Settings.Default.AssemblyFiles)
+            {
+                addCommandsFromAssemblyFile(assemblyFile);
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of types that are classes
+        /// and defined inside namespace specified 
+        /// in _commandNamespace
+        /// </summary>
+        /// <param name="assmbl">The Assembly to get the classes from</param>
+        /// <returns></returns>
+        static List<Type> listMatchingAssemblyTypes(Assembly assmbl)
+        {
+            var q = from t in assmbl.GetTypes()
+                    where t.IsClass && t.Namespace == CommandNamespace
+                    select t;
+            
+            return q.ToList();
+        }
+
+
+        /// <summary>
+        /// Adds public static methods from a list of classes
+        /// </summary>
+        /// <param name="owningAssembly"></param>
+        /// <param name="cmdClasses"></param>
+        static void addCommands(Assembly owningAssembly, List<Type> cmdClasses)
+        {
+            foreach (var commandClass in cmdClasses)
+            {
+                var methods = commandClass.GetMethods(BindingFlags.Static | BindingFlags.Public);
+                var methodDictionary = new Dictionary<string, IEnumerable<ParameterInfo>>();
+                foreach (var method in methods)
+                {
+                    string commandName = method.Name;
+                    methodDictionary.Add(commandName, method.GetParameters());
+                }
+                // Add the dictionary of methods for the current class into a dictionary of command classes:
+                CommandLibrary.Content.Add(commandClass.Name, new CommandClassInfo(owningAssembly, methodDictionary));
+            }
+        }
+
+        /// <summary>
+        /// adds suitable commands from a specified assembly file
+        /// </summary>
+        /// <param name="assemblyFile"></param>
+        public static void addCommandsFromAssemblyFile(string assemblyFile)
+        {
+            if (File.Exists(assemblyFile))
+            {
+                var extAssembly = Assembly.LoadFrom(assemblyFile);
+                var extCommandCLasses = listMatchingAssemblyTypes(extAssembly);
+
+                addCommands(extAssembly, extCommandCLasses);
+            }
+        }
+
+    }
+}
diff --git a/ConsoleApplicationBase/Commands/DefaultCommands.cs b/ConsoleApplicationBase/Commands/DefaultCommands.cs
index 6c79062..ab1bce4 100644
--- a/ConsoleApplicationBase/Commands/DefaultCommands.cs
+++ b/ConsoleApplicationBase/Commands/DefaultCommands.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -38,5 +39,24 @@ public static string DoSomethingOptional(int id, string data = "No Data Provided
             }
             return result;
         }
+
+        public static string AddExternalAssembly(string assemblyFile)
+        {
+            if (File.Exists(assemblyFile))
+            {
+                CommandLibrary.addCommandsFromAssemblyFile(assemblyFile);
+                return "added Assembly File : " + Path.GetFileName(assemblyFile);
+            }
+            else
+            {
+                return "Assembly file \'" + Path.GetFileName(assemblyFile) + "\' does not exist";
+            }
+        }
+
+        public static string Exit()
+        {
+            AppState.SetState(State.IDLE);
+            return "Exiting Application...";
+        }
     }
 }
diff --git a/ConsoleApplicationBase/ConsoleApplicationBase.csproj b/ConsoleApplicationBase/ConsoleApplicationBase.csproj
index 8c3be9f..b7854c0 100644
--- a/ConsoleApplicationBase/ConsoleApplicationBase.csproj
+++ b/ConsoleApplicationBase/ConsoleApplicationBase.csproj
@@ -33,6 +33,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -41,6 +42,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AppState.cs" />
+    <Compile Include="CommandClassInfo.cs" />
+    <Compile Include="CommandHandler.cs" />
+    <Compile Include="CommandLibrary.cs" />
     <Compile Include="Commands\DefaultCommands.cs" />
     <Compile Include="Commands\Users.cs" />
     <Compile Include="ConsoleCommand.cs" />
@@ -48,9 +53,18 @@
     <Compile Include="Models\SampleData.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+      <DependentUpon>Settings.settings</DependentUpon>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ConsoleApplicationBase/Program.cs b/ConsoleApplicationBase/Program.cs
index df8f793..ab18a7d 100644
--- a/ConsoleApplicationBase/Program.cs
+++ b/ConsoleApplicationBase/Program.cs
@@ -9,45 +9,17 @@ namespace ConsoleApplicationBase
 {
     class Program
     {
-        const string _commandNamespace = "ConsoleApplicationBase.Commands";
-        static Dictionary<string, Dictionary<string, IEnumerable<ParameterInfo>>> _commandLibraries;
-
         static void Main(string[] args)
         {
             Console.Title = typeof(Program).Name;
-
-            // Any static classes containing commands for use from the 
-            // console are located in the Commands namespace. Load 
-            // references to each type in that namespace via reflection:
-            _commandLibraries = new Dictionary<string, Dictionary<string, 
-                    IEnumerable<ParameterInfo>>>();
-
-            // Use reflection to load all of the classes in the Commands namespace:
-            var q = from t in Assembly.GetExecutingAssembly().GetTypes()
-                    where t.IsClass && t.Namespace == _commandNamespace
-                    select t;
-            var commandClasses = q.ToList();
-
-            foreach (var commandClass in commandClasses)
-            {
-                // Load the method info from each class into a dictionary:
-                var methods = commandClass.GetMethods(BindingFlags.Static | BindingFlags.Public);
-                var methodDictionary = new Dictionary<string, IEnumerable<ParameterInfo>>();
-                foreach (var method in methods)
-                {
-                    string commandName = method.Name;
-                    methodDictionary.Add(commandName, method.GetParameters());
-                }
-                // Add the dictionary of methods for the current class into a dictionary of command classes:
-                _commandLibraries.Add(commandClass.Name, methodDictionary);
-            }
+            
             Run();
         }
 
-
         static void Run()
         {
-            while (true)
+            AppState.SetState(State.RUNNING);
+            while (AppState.GetState() > State.IDLE)
             {  
                 var consoleInput = ReadFromConsole();
                 if (string.IsNullOrWhiteSpace(consoleInput)) continue;
@@ -58,7 +30,7 @@ static void Run()
                     var cmd = new ConsoleCommand(consoleInput);
 
                     // Execute the command:
-                    string result = Execute(cmd);
+                    string result = CommandHandler.Execute(cmd);
 
                     // Write out the result:
                     WriteToConsole(result);
@@ -71,299 +43,7 @@ static void Run()
             }
         }
 
-
-        static string Execute(ConsoleCommand command)
-        {
-            // Validate the class name and command name:
-            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-            string badCommandMessage = string.Format(""
-                + "Unrecognized command \'{0}.{1}\'. "
-                + "Please type a valid command.",
-                command.LibraryClassName, command.Name);
-
-            // Validate the command name:
-            if (!_commandLibraries.ContainsKey(command.LibraryClassName))
-            {
-                return badCommandMessage;
-            }
-            var methodDictionary = _commandLibraries[command.LibraryClassName];
-            if (!methodDictionary.ContainsKey(command.Name))
-            {
-                return badCommandMessage;
-            }
-
-            // Make sure the corret number of required arguments are provided:
-            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-            var methodParameterValueList = new List<object>();
-            IEnumerable<ParameterInfo> paramInfoList = methodDictionary[command.Name].ToList();
-
-            // Validate proper # of required arguments provided. Some may be optional:
-            var requiredParams = paramInfoList.Where(p => p.IsOptional == false);
-            var optionalParams = paramInfoList.Where(p => p.IsOptional == true);
-            int requiredCount = requiredParams.Count();
-            int optionalCount = optionalParams.Count();
-            int providedCount = command.Arguments.Count();
-
-            if (requiredCount > providedCount)
-            {
-                return string.Format(
-                    "Missing required argument. {0} required, {1} optional, {2} provided",
-                    requiredCount, optionalCount, providedCount);
-            }
-
-            // Make sure all arguments are coerced to the proper type, and that there is a 
-            // value for every emthod parameter. The InvokeMember method fails if the number 
-            // of arguments provided does not match the number of parameters in the 
-            // method signature, even if some are optional:
-            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-            if (paramInfoList.Count() > 0)
-            {
-                // Populate the list with default values:
-                foreach (var param in paramInfoList)
-                {
-                    // This will either add a null object reference if the param is required 
-                    // by the method, or will set a default value for optional parameters. in 
-                    // any case, there will be a value or null for each method argument 
-                    // in the method signature:
-                    methodParameterValueList.Add(param.DefaultValue);
-                }
-
-                // Now walk through all the arguments passed from the console and assign 
-                // accordingly. Any optional arguments not provided have already been set to 
-                // the default specified by the method signature:
-                for (int i = 0; i < command.Arguments.Count(); i++)
-                {
-                    var methodParam = paramInfoList.ElementAt(i);
-                    var typeRequired = methodParam.ParameterType;
-                    object value = null;
-                    try
-                    {
-                        // Coming from the Console, all of our arguments are passed in as 
-                        // strings. Coerce to the type to match the method paramter:
-                        value = CoerceArgument(typeRequired, command.Arguments.ElementAt(i));
-                        methodParameterValueList.RemoveAt(i);
-                        methodParameterValueList.Insert(i, value);
-                    }
-                    catch (ArgumentException ex)
-                    {
-                        string argumentName = methodParam.Name;
-                        string argumentTypeName = typeRequired.Name;
-                        string message =
-                            string.Format(""
-                            + "The value passed for argument '{0}' cannot be parsed to type '{1}'",
-                            argumentName, argumentTypeName);
-                        throw new ArgumentException(message);
-                    }
-                }
-            }
-
-            // Set up to invoke the method using reflection:
-            // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-            Assembly current = typeof(Program).Assembly;
-
-            // Need the full Namespace for this:
-            Type commandLibaryClass =
-                current.GetType(_commandNamespace + "." + command.LibraryClassName);
-
-            object[] inputArgs = null;
-            if (methodParameterValueList.Count > 0)
-            {
-                inputArgs = methodParameterValueList.ToArray();
-            }
-            var typeInfo = commandLibaryClass;
-
-            // This will throw if the number of arguments provided does not match the number 
-            // required by the method signature, even if some are optional:
-            try
-            {
-                var result = typeInfo.InvokeMember(
-                    command.Name,
-                    BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public,
-                    null, null, inputArgs);
-                return result.ToString();
-            }
-            catch (TargetInvocationException ex)
-            {
-                throw ex.InnerException;
-            }
-        }
-
-
-        static object CoerceArgument(Type requiredType, string inputValue)
-        {
-            var requiredTypeCode = Type.GetTypeCode(requiredType);
-            string exceptionMessage = 
-                string.Format("Cannnot coerce the input argument {0} to required type {1}", 
-                inputValue, requiredType.Name);
-
-            object result = null;
-            switch (requiredTypeCode)
-            {
-                case TypeCode.String:
-                    result = inputValue;
-                    break;
-
-                case TypeCode.Int16:
-                    short number16;
-                    if (Int16.TryParse(inputValue, out number16))
-                    {
-                        result = number16;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-
-                case TypeCode.Int32:
-                    int number32;
-                    if (Int32.TryParse(inputValue, out number32))
-                    {
-                        result = number32;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-
-                case TypeCode.Int64:
-                    long number64;
-                    if (Int64.TryParse(inputValue, out number64))
-                    {
-                        result = number64;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-
-                case TypeCode.Boolean:
-                    bool trueFalse;
-                    if (bool.TryParse(inputValue, out trueFalse))
-                    {
-                        result = trueFalse;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-
-                case TypeCode.Byte:
-                    byte byteValue;
-                    if (byte.TryParse(inputValue, out byteValue))
-                    {
-                        result = byteValue;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-
-                case TypeCode.Char:
-                    char charValue;
-                    if (char.TryParse(inputValue, out charValue))
-                    {
-                        result = charValue;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-
-                case TypeCode.DateTime:
-                    DateTime dateValue;
-                    if (DateTime.TryParse(inputValue, out dateValue))
-                    {
-                        result = dateValue;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                case TypeCode.Decimal:
-                    Decimal decimalValue;
-                    if (Decimal.TryParse(inputValue, out decimalValue))
-                    {
-                        result = decimalValue;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                case TypeCode.Double:
-                    Double doubleValue;
-                    if (Double.TryParse(inputValue, out doubleValue))
-                    {
-                        result = doubleValue;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                case TypeCode.Single:
-                    Single singleValue;
-                    if (Single.TryParse(inputValue, out singleValue))
-                    {
-                        result = singleValue;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                case TypeCode.UInt16:
-                    UInt16 uInt16Value;
-                    if (UInt16.TryParse(inputValue, out uInt16Value))
-                    {
-                        result = uInt16Value;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                case TypeCode.UInt32:
-                    UInt32 uInt32Value;
-                    if (UInt32.TryParse(inputValue, out uInt32Value))
-                    {
-                        result = uInt32Value;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                case TypeCode.UInt64:
-                    UInt64 uInt64Value;
-                    if (UInt64.TryParse(inputValue, out uInt64Value))
-                    {
-                        result = uInt64Value;
-                    }
-                    else
-                    {
-                        throw new ArgumentException(exceptionMessage);
-                    }
-                    break;
-                default:
-                    throw new ArgumentException(exceptionMessage);
-            }
-            return result;
-        }
-
-
-        public static void WriteToConsole(string message = "")
+        static void WriteToConsole(string message = "")
         {
             if(message.Length > 0)
             {
@@ -371,9 +51,8 @@ public static void WriteToConsole(string message = "")
             }
         }
 
-
         const string _readPrompt = "console> ";
-        public static string ReadFromConsole(string promptMessage = "")
+        static string ReadFromConsole(string promptMessage = "")
         {
             // Show a prompt, and get input:
             Console.Write(_readPrompt + promptMessage);
diff --git a/ConsoleApplicationBase/Properties/Settings.Designer.cs b/ConsoleApplicationBase/Properties/Settings.Designer.cs
new file mode 100644
index 0000000..5adb5b7
--- /dev/null
+++ b/ConsoleApplicationBase/Properties/Settings.Designer.cs
@@ -0,0 +1,41 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     Dieser Code wurde von einem Tool generiert.
+//     Laufzeitversion:4.0.30319.42000
+//
+//     Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn
+//     der Code erneut generiert wird.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace ConsoleApplicationBase.Properties {
+    
+    
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.1.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+        
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+        
+        public static Settings Default {
+            get {
+                return defaultInstance;
+            }
+        }
+        
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute(@"<?xml version=""1.0"" encoding=""utf-16""?>
+<ArrayOfString xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
+  <string>C:\Users\rdoe\Dropbox\TEX\Masterarbeit\src\consoleApp\ConsoleApplicationBase\TestLib\bin\Debug\TestLib.dll</string>
+</ArrayOfString>")]
+        public global::System.Collections.Specialized.StringCollection AssemblyFiles {
+            get {
+                return ((global::System.Collections.Specialized.StringCollection)(this["AssemblyFiles"]));
+            }
+            set {
+                this["AssemblyFiles"] = value;
+            }
+        }
+    }
+}
diff --git a/ConsoleApplicationBase/Properties/Settings.settings b/ConsoleApplicationBase/Properties/Settings.settings
new file mode 100644
index 0000000..f59cf1a
--- /dev/null
+++ b/ConsoleApplicationBase/Properties/Settings.settings
@@ -0,0 +1,12 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" GeneratedClassNamespace="ConsoleApplicationBase.Properties" GeneratedClassName="Settings">
+  <Profiles />
+  <Settings>
+    <Setting Name="AssemblyFiles" Type="System.Collections.Specialized.StringCollection" Scope="User">
+      <Value Profile="(Default)">&lt;?xml version="1.0" encoding="utf-16"?&gt;
+&lt;ArrayOfString xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;
+  &lt;string&gt;C:\Users\rdoe\Dropbox\TEX\Masterarbeit\src\consoleApp\ConsoleApplicationBase\TestLib\bin\Debug\TestLib.dll&lt;/string&gt;
+&lt;/ArrayOfString&gt;</Value>
+    </Setting>
+  </Settings>
+</SettingsFile>
\ No newline at end of file
diff --git a/TestLib/Properties/AssemblyInfo.cs b/TestLib/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..98d4571
--- /dev/null
+++ b/TestLib/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die einer Assembly zugeordnet sind.
+[assembly: AssemblyTitle("TestLib")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("TestLib")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("2304b2f5-905d-46cd-9bc1-f10973fbedc4")]
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
+// indem Sie "*" wie unten gezeigt eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/TestLib/TestClass.cs b/TestLib/TestClass.cs
new file mode 100644
index 0000000..59b6d3e
--- /dev/null
+++ b/TestLib/TestClass.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ConsoleApplicationBase.Commands
+{
+    public static class TestClass
+    {
+        public static string RunTestMethod()
+        {
+            return "ran test method!";
+        }
+
+        public static string RunAnotherMethod(string name)
+        {
+            return "Ran another Method named: " + name;
+        }
+    }
+}
diff --git a/TestLib/TestLib.csproj b/TestLib/TestLib.csproj
new file mode 100644
index 0000000..01bc5a3
--- /dev/null
+++ b/TestLib/TestLib.csproj
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{2304B2F5-905D-46CD-9BC1-F10973FBEDC4}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>TestLib</RootNamespace>
+    <AssemblyName>TestLib</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="TestClass.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file