In your Main() method:

• Initialize your Program class's CommandLineType object with the type of prompt you want it to display.
• Create a new CommandType object for each possible command your program supports.
• For each command object, add ParameterType objects for each parameter your commands take.
• Commands and Parameters have event handlers to handle the execution of the commands and validation of the parameters.
• Don't forget to provide help text for each command and each parameter. The CommandLine library automatically handles the "Help" command and displays YOUR help text.
• The CommandLineType already supports an Exit command, but feel free to add your own to handle exiting the way you need to.
• After it's all set up, call your command object's ExecDosCommand() method, passing it the args array sent into the Main() method.
• If there were to args passed in, then just call your command object's Execute() method to get it started.

static void Main(string[] args)
{
    //Instantiate the command line object, giving the initial display prompt.
    _cl = new CommandLineType("Example", ">");

    //Instantiate a command object, along with some simple help text and a reference to the command's callback function.
    var testCommand = new CommandType(
        commandEventHandler: TestCommand_CommandFunction,
        consoleEntry       : "test",
        shortHelpString    : "Just a sample command.");

    //Add a parameter that can be used.
    var parm = new ParameterType(
        eventHandler    : Parm_ValidateFunction,
        parmLabel       : "SomeParm",
        equationString  : "=", //What you expecte between the parm name and value (SomeParm = Hello).
        defaultUserValue: "Hello",
        shortHelpString : "A sample command parameter that defaults to value \"Hello\".");

    //Add a parameter that can be used.
    var parm2 = new ParameterType(
        eventHandler    : Parm_ValidateFunction,
        parmLabel       : "SomethingElse",
        equationString  : "=", //What you expecte between the parm name and value (SomethingElse = World).
        defaultUserValue: "World",
        shortHelpString : "A sample command parameter that defaults to value \"World\".");

    testCommand.ParameterList.Add(parm);
    testCommand.ParameterList.Add(parm2);

    //Add the command to the command line object so it can process it when users enter it.
    _cl.AddCommand(testCommand);

    //Tell it which of your commands exits the program (you can add extra functionality to the exit process here).
    //Comment out the next line and you'll get the custom exit command instead, along with its default help.
    _cl.SetExitCommand(new CommandType((NotifyEventDelegate)null, "Quit", "My custom exit command."));

    if (args.Length > 0)
    {
        //If launched from the OS console (or anywhere else) with parms passed in,
        //execute the one command and exit.
        _cl.ExecDosCommand(args);
    }
    else
    {
        DisplayWelcome(_cl);

        //Start up the command line.  It won't stop until someone enters the text you provided
        //  for the exit command OR if you provided no exit command, when the user types the
        //  text for the default exit command, which is "Exit".
        _cl.Execute();
    }
}

static void Main(string[] args)
{
    _cl = new CommandLineType("Example", ">");

    var testCommand = new CommandType(TestCommand_CommandFunction, "test", "Just a sample command.");
    testCommand.ParameterList.Add(new ParameterType(Parm_ValidateFunction, "SomeParm", "=", "Hello", "A sample command parameter that defaults to value \"Hello\"."));
    testCommand.ParameterList.Add(new ParameterType(Parm_ValidateFunction, "SomethingElse", "=", "World", "A sample command parameter that defaults to value \"World\"."));

    _cl.AddCommand(testCommand);
    _cl.SetExitCommand(new CommandType((NotifyEventDelegate)null, "Quit", "My custom exit command."));

    if (args.Length > 0)
        _cl.ExecDosCommand(args);
    else
    {
        DisplayWelcome(_cl);
        _cl.Execute();
    }
}

private static void DisplayWelcome(CommandLineType cl)
{
    //Write a little intro for the users on startup...
    //Notice your CommandLineType object has an output stream.  You should always use this
    //instead of Console.WriteLine because you can change OutputStream to any stream you want.
    //CL defaults to the System.Console.Out TextWriter, but you can change it ot anything you want.

    cl.OutputStream.WriteLine("*******************************************************************");
    cl.OutputStream.WriteLine("*                                                                 *");
    cl.OutputStream.WriteLine("*  #     #           ##                                       ##  *");
    cl.OutputStream.WriteLine("*  #     #            #                                       ##  *");
    cl.OutputStream.WriteLine("*  #     #            #                                       ##  *");
    cl.OutputStream.WriteLine("*  #     #            #                                       ##  *");
    cl.OutputStream.WriteLine("*  #  #  #  #####     #     #####   #####  ### ##   #####     ##  *");
    cl.OutputStream.WriteLine("*  # ### # #     #    #    #     # #     # ## #  # #     #    ##  *");
    cl.OutputStream.WriteLine("*  ### ### #######    #    #       #     # #  #  # #######    ##  *");
    cl.OutputStream.WriteLine("*  ##   ## #          #    #     # #     # #  #  # #              *");
    cl.OutputStream.WriteLine("*  #     #  #####    ###    #####   #####  #     #  #####     ##  *");
    cl.OutputStream.WriteLine("*                                                                 *");
    cl.OutputStream.WriteLine("*******************************************************************\r\n");

    cl.OutputStream.WriteLine("Welcome to the CommandLine sample Console application.");
    cl.OutputStream.WriteLine("Type \"Help\".");
}

Add a validation function to each ParameterType object you add to your commands. You can access the parameter name and the user provided value from the sender object. Then you can analyze the values any way you see fit. Return true if you're happy with it. Return false to inform the CommandLine library that the parameter is invalid so it can properly handle the error condition.

In this example, it's displaying the name and value of the parameter (To the command line' s output stream), then checking to see if the user's value of the paremeter was entered as "fail", and if so, simulating a failure by returning false. Otherwise, it returns true, for success. ANY type of processing can happen here that you see fit.

private static bool Parm_ValidateFunction(object sender)
{
    var parm = (ParameterType) sender;
    _cl.OutputStream.WriteLine($"Parameter recognized \"{parm.ParamText}\" with value \"{parm.UserValue}\".");

    if (parm.UserValue.ToLower() == "fail")
        return false;

    return true;
}

Each command object you create needs an event handler. This is where the guts of your command functionality lie. When the user types that command, the proper event handler will automatically be called. You are sent the command object in the sender object in your event handler. By this time, the user provided parameters have already been validated. The command object has access to all the properties of the command the user typed, INCLUDING the parameter objects and all the values the user provided. Handle the execution of the command any way you see fit. Return true if everything went well (according to YOUR definition of "well"). Return false if you determined something wasn't right.

/// <summary>
/// The event handler for the Test command.  This will be called automatically when the user enters the "test" command.
/// You write the code to handle the "Test" command here.
/// </summary>
/// <param name="sender">The sending CommandType object.</param>
/// <returns>You return true or false depending on whether you determined this succeeded or failed.</returns>
private static bool TestCommand_CommandFunction(object sender)
{
    var command = (CommandType) sender;

    var cl = command.GetOwnerCommandLine();
    cl.OutputStream.WriteLine($"You entered [{command.ConsoleEntry}]");

    if (command.ConsoleEntry.Contains("fail"))
        return false;

    return true;
}

Instantiate the CommandLineType object and initialize it with a prompt.

private CL.CommandLineType _commandLine = new CL.CommandLineType("Example", ">");

On the event handler for the File->New Console menu, create a new child form to host the CLI:

private void File_NewConsoleToolStripMenuItem_Click(object sender, EventArgs e)
{
    //Create the Console window, passing it the command line object.
    //That's where the user will interact with the command line.
    var console = new ConsoleFormType(this._commandLine);
    console.Owner = this;
    console.MdiParent = this;
    console.Show();
}

On the Shown() event handler, add a command to the command line object and assign a StringWriter to the command line object's OutputStream. You'll use the OutputStream later to hook into the command line's output so you can display it in a TextBox control.

private void MainFormType_Shown(object sender, EventArgs e)
{
    //Add a sample command to the command line object and point it to its event handler and give it some help text.
    var testCommand = new CL.CommandType(TestCommand_CommandFunction, "Test", "Sample command");
    this._commandLine.AddCommand(testCommand);

    //Since we're not using the Console, we need to trap the output so we can do something with it.
    //A StringWriter will work just fine for this purpose.
    //Our ConsoleFormType window can capture the output and display it however it likes.
    this._commandLine.OutputStream = new StringWriter();

    //Notice there's no exit command?  That's not needed in a winforms app.
    //Whatever control is passing the input to the command line object can check for an exit command (if it wants to).
    //Also notice that we're NOT calling this._commandLine.Execute()?  Again, thats because we're NOT using an actual
    //Console app.  We're handling keyboard input from a standard TextBox control and CALLING CommandLineType.ExecCommand()
    //and passing it the text from our input textbox, so there's no concept of "exiting" the CommandLineType object.
}

The example command you added to the command line object in the MainFormType_Shown() event handler is defined here. When that command is executed by the user, this will be executed to handle it. This event handler does TWO things:

• Writes something to the command line's output stream. Notice we're not worried about WinForms controls?
• Displays a MessageBox. This is to demonstrate that just because activity was initiated by a command line, doesn't mean you're limited to ONLY command line activities. You can do anything you like.

/// <summary>
/// Event handler for the "test" command object.  This example purposely writes it here, in the MainForm,
/// rather than the ConsoleForm so that you can see that it doesn't need to know anything about the ConsoleForm
/// to output text to it.  It simply writes to the _commandLine.OutputStream.  The ConsoleForm will capture any
/// text written to that stream and display it however it likes.
/// </summary>
/// <param name="sender">The command object that owns the comment that was processed.</param>
/// <returns></returns>
private bool TestCommand_CommandFunction(object sender)
{
    var command = (CL.CommandType) sender;

    //Write to the command line's output.  It will be handled by the console form.
    _commandLine.OutputStream.WriteLine($"Test command executed [{command.ConsoleEntry}] and handled in the MainForm.");
    MessageBox.Show("This dialog box is being created from the MainForm and the command line is responding by doing something Windowy.  Command event handlers can do anything, not just command line like stuff.", $"You used the {command.ConsoleEntry} command.");

    return true;
}

The ConsoleForm is a child window where we'll be accepting user entered commands and displaying the output.

Create a private field for a CommandLine object. The MainForm will pass an instance into the constructor of this ConsoleForm. In our constructor, we'll accept it and assign it to our private reference.

private readonly CommandLineType _commandLine;

The MainForm passes its single CommandLine object to us and we simpliy assign it to our local, private instance of it. The user can open as many ConsoleForm windows as they like. They'll all share the same instance of the CommandLine object.

public ConsoleFormType(CommandLineType commandLine)
{
    this._commandLine = commandLine;
    InitializeComponent();
}

We'll hook into our CommandTextBox's KeyPress event. We won't do anything special until the user hits the [Enter] key. Once they do that, we'll ask the command line object to process the command for us. We'll also check to see if the user entered the CommandLine object's Exit command and handle the exit request. Then we'll capture the output from the CommandLine object's output stream and display it in our OoutputTextBox.

Unlike an actual console application, where we call the CommandLine object's Execute() method, we're working in a fundamentally different kind of environment in a WinForms application. This is an event driving environment. So, instead of sending all processing the CommandLine.Execute() command, we do slightly more work by watching out own user interface control and sending the user entered command to the command line object's ExectCommand() method and manually check if they requested to exit.

private void CommandTextBox_KeyPress(object sender, KeyPressEventArgs e)
{
    //Check if user hit the enter key.  Handle ANY command here.
    //All we're doing is asking the command line to execute the
    //command, capturing the output, and checking if they want to exit.
    //We're NOT processing the commands.  That's the job of the CommandLineType.ExecCommand().
    if ((int) e.KeyChar == (int) us.FreeWill.SpecialKeysEnum.CR)
    {
        //Send the user entered command to the command line's ExecCommand() method to be processed.
        var commandResult = this._commandLine.ExecCommand(this.CommandTextBox.Text);

        //Check if the user entered whatever command triggered the exit event.
        if (commandResult == CommandResultEnum.Exit)
            this.Close(); //close this window if the user entered the exit command.

        //Capture the command's ouput and display in the OutputTextBox.
        this.OutputTextBox.Text += this._commandLine.OutputStream.ToString();

        //Reassign the OutputStream to a new StringWriter() (old one will not let go of old output).
        this._commandLine.OutputStream = new StringWriter();

        //Show whether or not the command was successful.
        this.OutputTextBox.Text += $"\r\rResult = {commandResult}.\r\n\r\n";

        //Clear the input box.
        ((TextBox)sender).Text = string.Empty;

        //Scroll to the bottom so we can see what was just added:
        this.OutputTextBox.SelectionStart = this.OutputTextBox.Text.Length;
        this.OutputTextBox.ScrollToCaret();
    }
}

This is from the provided ASP.Net MVC application that demostrates how to use the CommandLine in a web application.

The Index() method is just your standard MVC Index action.

public ActionResult Index()
{
    return View();
}

This is the action method to load the CommandLine view page.

public ActionResult CommandLine()
{
    ViewBag.Message = "Command Line";

    return View();
}

Instantiate the CommandLineType object and initialize it with a prompt.

private CL.CommandLineType _commandLine = new CL.CommandLineType("Example", ">");

When the user enters a command on the CommandLine page, it's sent to this action method.

Now's a good time to review the CommandLineViewModel:

public class CommandLineViewModel
{
    public string ConsoleEntry { get; set; }
    public string Output       { get; set; } = string.Empty;
}

Though the model is sent to this action method, this is not the handler for any particular command. Here is where the accepted user commands are created as command objects and their accepted parameters are added to the commands in the form of paramter objects.

[HttpPost]
public ActionResult CommandLine(CommandLineViewModel model)
{
    //The code below was copied from the WinForms sample project, with minor modifications...

    //Add a sample command to the command line object and point it to its event handler and give it some help text.
    var testCommand = new CL.CommandType(TestCommand_CommandFunction, "Test", "Sample command");
    this._commandLine.AddCommand(testCommand);

    //A date command with help and a format paramter object.
    var dateCommand = new CL.CommandType(DateCommand_CommandEventHandler, "Date", "Gets the current date.");
    var dateFormatParm = new CL.ParameterType(null, "Format", "=", "f", "Sets the format of the date display");
    dateFormatParm.ShortHelp.Add("https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings");
    dateCommand.ParameterList.Add(dateFormatParm);
    this._commandLine.AddCommand(dateCommand);

    //Since we're not using the Console, we need to trap the output so we can do something with it.
    //A StringWriter will work just fine for this purpose.
    //We'll capture the output via the _commandLine.OutputStream and put it in the ViewModel.
    this._commandLine.OutputStream = new StringWriter();

    //Notice there's no exit command?  That's not needed in a web UI app.
    //Whatever control is passing the input to the command line object can check for an exit command (if it wants to).
    //Also notice that we're NOT calling this._commandLine.Execute()?  Again, thats because we're NOT using an actual
    //Console app.  We're handling keyboard input from a standard Html.TextBoxFor() control from the view and CALLING
    //CommandLineType.ExecCommand() here and passing it the text from our input textbox, so there's no concept of
    //"exiting" the CommandLineType object.  However, we're going to respond to "exit" anyway and redirect them
    //to the Index action method to send them back to the home page.

    //Send the user entered command to the command line's ExecCommand() method to be processed.
    var commandResult = this._commandLine.ExecCommand(model.ConsoleEntry);

    //Check if the user entered whatever command triggered the exit event.
    switch (commandResult)
    {
        case CL.CommandResultEnum.Fail:
            model.Output += "Command not recognized.";
            break;
        case CL.CommandResultEnum.Exit:
            return RedirectToAction("Index", "Home");
    }

    //Capture the command's ouput and assign to the view model.
    model.Output += this._commandLine.OutputStream.ToString(); //.Replace(" ", " "); //.Replace(Environment.NewLine, "<br />"); ;

    //Reassign the OutputStream to a new StringWriter() (old one will not let go of old output).
    this._commandLine.OutputStream = new StringWriter();

    return View(model);
}

When a user enters a command, the CommandLine object parses it and triggers events in the appropriate places. This method is an event handler that's fired when the user enters the date command. It ensures the value the user entered a valid date formatter and displays the current date and time in the format specified by the user.

Notice the output is sent to the command line object's OutputStream? That's important. Nothing Web-like is hapenning in this event handler. This is 100% command line stuff. The output is captured in the CommandLine action method above and displayed accordingly.

private bool DateCommand_CommandEventHandler(object sender)
{
    var command = (CL.CommandType)sender;

    var parm = command.GetParameterByName("Format"); //TODO: event handler not firing if user enters parameters.

    string display = "Unrecognized format specifier";
    try
    {
        display = DateTime.Now.ToString(parm.UserValue);
    }
    catch (Exception ex)
    {
        display = ex.Message;

    }

    _commandLine.OutputStream.WriteLine($"{display}");

    return true;
}

Again, zero web-like activity happens here. This is the event handler for the "Test" command. It's processed and output is sent to the CommandLine object's output stream.

/// <summary>
/// Event handler for the "test" command object.  It simply writes to the _commandLine.OutputStream.
/// The controller action will capture any text written to that stream and display it however it likes.
/// </summary>
/// <param name="sender">The command object that owns the comment that was processed.</param>
/// <returns>True for success, false for failure.</returns>
private bool TestCommand_CommandFunction(object sender)
{
    var command = (CL.CommandType)sender;

    //Write to the command line's output.
    _commandLine.OutputStream.WriteLine($"Test command executed [{command.ConsoleEntry}].");

    return true;
}

This is the only model used in the ASP.Net MVC sample application. When the user enters a command, their entry is stored in the ConsoleEntry field. Once the CommandLine object does its processing and writes its own output to its OutputStream, the MVC app grabs that output and redirects it to the CommandLineViewModel.Output field, where an action method uses that to display it on the web page.

public class CommandLineViewModel
{
    public string ConsoleEntry { get; set; }
    public string Output       { get; set; } = string.Empty;
}

This is the simple contents of the page that accepts the user entered commands and displays the output of those commands. There's nothing to it. It posts the user command to the Home controller's CommandLine action method.

<p>Try out the Command Line library here.  Type "Help" for a list of commands.</p>


@using (Html.BeginForm("CommandLine", "Home", FormMethod.Post, new { @class = "form-horizontal", role = "form" }))
{
    <div class="jumbotron">
        Type "Help" for a list of available commands.<br />
        @Html.LabelFor(m => m.ConsoleEntry)
        @Html.TextBoxFor(m => m.ConsoleEntry)
        <hr />

        @if (Model != null)
        {
            <tt style="white-space: pre;">@Model.Output</tt>
        }
    </div>
}

@section Scripts {
    @Scripts.Render("~/bundles/jqueryval")
}