CommandLineParser.Core 1.0.1

Install-Package CommandLineParser.Core -Version 1.0.1
dotnet add package CommandLineParser.Core --version 1.0.1
<PackageReference Include="CommandLineParser.Core" Version="1.0.1" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add CommandLineParser.Core --version 1.0.1
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: CommandLineParser.Core, 1.0.1"
#r directive can be used in F# Interactive, C# scripting and .NET Interactive. Copy this into the interactive tool or source code of the script to reference the package.
// Install CommandLineParser.Core as a Cake Addin
#addin nuget:?package=CommandLineParser.Core&version=1.0.1

// Install CommandLineParser.Core as a Cake Tool
#tool nuget:?package=CommandLineParser.Core&version=1.0.1
The NuGet Team does not provide support for this client. Please contact its maintainers for support.


A simple, strongly typed .NET C# command line parser library using a fluent easy to use interface.

This library for .NET Core and .NET Standart 2.0


You can also install using NuGet via the command line

nuget install CommandLineParser.Core

Or use the Package Manager console in Visual Studio:

Install-Package CommandLineParser.Core


using CommandLineParser.Core;

public class ApplicationArguments
   public int RecordId { get; set; }
   public bool Silent { get; set; }
   public string NewValue { get; set; }

static void Main(string[] args)
   // create a generic parser for the ApplicationArguments type
   var p = new FluentCommandLineParser<ApplicationArguments>();

   // specify which property the value will be assigned too.
   p.Setup(arg => arg.RecordId)
    .As('r', "record") // define the short and long option name
    .Required(); // using the standard fluent Api to declare this Option as required.

   p.Setup(arg => arg.NewValue)
    .As('v', "value")

   p.Setup(arg => arg.Silent)
    .As('s', "silent")
    .SetDefault(false); // use the standard fluent Api to define a default value if non is specified in the arguments

   var result = p.Parse(args);

   if(result.HasErrors == false)
      // use the instantiated ApplicationArguments object from the Object property on the parser.

You can also use the non-generic Fluent Command Line Parser to capture values without creating a container class.

static void Main(string[] args)
  var p = new FluentCommandLineParser();

   .Callback(record => RecordID = record)

   .Callback(value => NewValue = value)

  p.Setup<bool>('s', "silent")
   .Callback(silent => InSilentMode = silent)


Parser Option Methods

.Setup<int>('r') Setup an option using a short name,

.Setup<int>('r', "record") or short and long name.

.Required() Indicate the option is required and an error should be raised if it is not provided.

.Callback(val => Value = val) Provide a delegate to call after the option has been parsed

.SetDefault(int.MaxValue) Define a default value if the option was not specified in the args

.WithDescription("Execute operation in silent mode without feedback") Specify a help description for the option

Parsing To Collections

Many arguments can be collected as part of a list. Types supported are string, int32, int64, double, bool, Uri, DateTime and Enum

For example arguments such as

--filenames C:\file1.txt C:\file2.txt "C:\other file.txt"

can be automatically parsed to a List<string> using

static void Main(string[] args)
   var p = new FluentCommandLineParser();

   var filenames = new List<string>();

   p.Setup<List<string>>('f', "filenames")
    .Callback(items => filenames = items);


   Console.WriteLine("Input file names:");

   foreach (var filename in filenames)


Input file names
C:\other file.txt

Enum support

Since v1.2.3 enum types are now supported.

enum Direction
	North = 1,
	East = 2,
	South = 4,
	West = 8,
 .Callback(d => direction = d);

To specify 'East' direction either the text can be provided or the enum integer.

dosomething.exe --direction East
dosomething.exe --direction 2

You can also collect multiple Enum values into a List<TEnum>

List<Direction> direction;

p.Setup<List<Direction>>('d', "direction")
 .Callback(d => direction = d);

For example, specifiying 'South' and 'East' values

dosomething.exe --direction South East
dosomething.exe --direction 4 2

Since v1.4 Enum Flags are also supported

Direction direction;

 .Callback(d => direction = d);



And the generic FluentCommandLineParser<T> (previously known as FluentCommandLineBuilder) also supports enums.

public class Args
   public Direction Direction { get;set; }
   public List<Direction> Directions { get;set; }
var p = new FluentCommandLineParser<Args>();

p.Setup(args => args.Direction)
 .As('d', "direction");

p.Setup(args => args.Directions)

From v1.5 nullable enums are now supported.

Help Screen

You can setup any help arguments, such as -? or --help to print all parameters which have been setup, along with their descriptions to the console by using SetupHelp(params string[]).

For example:

// sets up the parser to execute the callback when -? or --help is detected
parser.SetupHelp("?", "help")
      .Callback(text => Console.WriteLine(text));

Since v1.4.1 you can also choose to display the formatted help screen text manually, so that you can display it under other circumstances.

For example:

var parser = new FluentCommandLineParser<Args>();
parser.SetupHelp("?", "help")
      .Callback(text => Console.WriteLine(text));
// triggers the SetupHelp Callback which writes the text to the console

Supported Syntax

[-|--|/][switch_name][=|:| ][value]

Supports boolean names

example.exe -s  // enable
example.exe -s- // disabled
example.exe -s+ // enable

Supports combined (grouped) options

example.exe -xyz  // enable option x, y and z
example.exe -xyz- // disable option x, y and z
example.exe -xyz+ // enable option x, y and z


Please feel free to provide any feedback on feature support or the Api itself.

If you would like to contribute, you may do so to the develop branch. Please contact me first if doing large scale changes.

  • .NETStandard 2.0

    • No dependencies.

NuGet packages (1)

Showing the top 1 NuGet packages that depend on CommandLineParser.Core:

Package Downloads

Configure FPGA with subset of C#. Toolkit contains set of tools and utilities to produce VHDL and Verilog from C# source code files

GitHub repositories (1)

Showing the top 1 popular GitHub repositories that depend on CommandLineParser.Core:

Repository Stars
Version Downloads Last updated
1.0.1 31,906 11/9/2017
1.0.0 902 11/9/2017

Latest version v1.0.1