DotArgs.CommandLineArgs Class Reference

Class for defining, validating and processing command line arguments. More...

Public Member Functions
	CommandLineArgs ()
	Initializes a new instance of the CommandLineArgs class. More...
void	AddExample (string description, string commandLine)
	Adds an example that will be displayed on the help page. More...
T	GetValue< T > (string name)
	Gets the value of an argument. More...
void	PrintHelp (string errorMessage=null)
	Prints a help message describing the effects of all available options. More...
void	Process ()
	Processes all registered arguments that have their Argument.Processor set. More...
void	RegisterAlias (string originalName, string alias)
	Registers an alias for an existing entry. More...
void	RegisterArgument (string name, Argument arg)
	Registers a new argument. More...
void	RegisterHelpArgument (string name="help")
	Registers a help argument that will display the help page for the program if set by the user. More...
void	SetDefaultArgument (string argument)
	Sets the default argument that will be filled when no argument name is given. More...
bool	Validate (string[] args, OptionalOut< string[]> outErrors=null)
	Processes a set of command line arguments. More...
bool	Validate (string args, OptionalOut< string[]> outErrors=null)
	Processes a set of command line arguments. More...
	CommandLineArgs ()
	Initializes a new instance of the CommandLineArgs class. More...
void	AddExample (string description, string commandLine)
	Adds an example that will be displayed on the help page. More...
T	GetValue< T > (string name)
	Gets the value of an argument. More...
void	PrintHelp (string errorMessage=null)
	Prints a help message describing the effects of all available options. More...
void	Process ()
	Processes all registered arguments that have their Argument.Processor set. More...
void	RegisterAlias (string originalName, string alias)
	Registers an alias for an existing entry. More...
void	RegisterArgument (string name, Argument arg)
	Registers a new argument. More...
void	RegisterHelpArgument (string name="help")
	Registers a help argument that will display the help page for the program if set by the user. More...
void	SetDefaultArgument (string argument)
	Sets the default argument that will be filled when no argument name is given. More...
bool	Validate (string[] args, OptionalOut< string[]> outErrors=null)
	Processes a set of command line arguments. More...
bool	Validate (string args, OptionalOut< string[]> outErrors=null)
	Processes a set of command line arguments. More...
	CommandLineArgs ()
	Initializes a new instance of the CommandLineArgs class. More...
void	AddExample (string description, string commandLine)
	Adds an example that will be displayed on the help page. More...
T	GetValue< T > (string name)
	Gets the value of an argument. More...
void	PrintHelp (string errorMessage=null)
	Prints a help message describing the effects of all available options. More...
void	Process ()
	Processes all registered arguments that have their Argument.Processor set. More...
void	RegisterAlias (string originalName, string alias)
	Registers an alias for an existing entry. More...
void	RegisterArgument (string name, Argument arg)
	Registers a new argument. More...
void	RegisterHelpArgument (string name="help")
	Registers a help argument that will display the help page for the program if set by the user. More...
void	SetDefaultArgument (string argument)
	Sets the default argument that will be filled when no argument name is given. More...
bool	Validate (string[] args, OptionalOut< string[]> outErrors=null)
	Processes a set of command line arguments. More...
bool	Validate (string args, OptionalOut< string[]> outErrors=null)
	Processes a set of command line arguments. More...

Properties
string	ApplicationInfo [get, set]
	Information about the application that will be displayed in the usage page. More...
string	ExecuteableName [get, set]
	Name of the executeable that will be displayed in the usage page. More...
TextWriter	OutputWriter [get, set]
	The TextWriter that is used to write the output. The default value is to use Console.Out More...

Detailed Description

Class for defining, validating and processing command line arguments.

Constructor & Destructor Documentation

CommandLineArgs() [1/3]

DotArgs.CommandLineArgs.CommandLineArgs

(

)

Initializes a new instance of the CommandLineArgs class.

        {
            OutputWriter = Console.Out;
            ExecuteableName = Path.GetFileNameWithoutExtension( Assembly.GetCallingAssembly().Location );
        }

CommandLineArgs() [2/3]

DotArgs.CommandLineArgs.CommandLineArgs

(

)

Initializes a new instance of the CommandLineArgs class.

        {
            OutputWriter = Console.Out;
            ExecuteableName = Path.GetFileNameWithoutExtension( Assembly.GetCallingAssembly().Location );
        }

CommandLineArgs() [3/3]

DotArgs.CommandLineArgs.CommandLineArgs

(

)

Initializes a new instance of the CommandLineArgs class.

        {
            OutputWriter = Console.Out;
            ExecuteableName = Path.GetFileNameWithoutExtension( Assembly.GetCallingAssembly().Location );
        }

Member Function Documentation

AddExample() [1/3]

void DotArgs.CommandLineArgs.AddExample	(	string	description,
		string	commandLine
	)

Adds an example that will be displayed on the help page.

Parameters

description	The name or description for this example.
commandLine	The command line to display for this example.

        {
            Examples.Add( description, commandLine );
        }

AddExample() [2/3]

void DotArgs.CommandLineArgs.AddExample	(	string	description,
		string	commandLine
	)

Adds an example that will be displayed on the help page.

Parameters

description	The name or description for this example.
commandLine	The command line to display for this example.

        {
            Examples.Add( description, commandLine );
        }

AddExample() [3/3]

void DotArgs.CommandLineArgs.AddExample	(	string	description,
		string	commandLine
	)

Adds an example that will be displayed on the help page.

Parameters

description	The name or description for this example.
commandLine	The command line to display for this example.

        {
            Examples.Add( description, commandLine );
        }

GetValue< T >() [1/3]

T DotArgs.CommandLineArgs.GetValue< T >

(

string

name

)

Gets the value of an argument.

Parameters

name	Name of the argument to read.

Returns

The effective value of the argument. If the argument was omitted in the arguments, the default value will be returned.

Exceptions

System.Collections.Generic.KeyNotFoundException

An argument with the name name was not registered.

        {
            if( !Arguments.ContainsKey( name ) )
            {
                throw new KeyNotFoundException( string.Format( "An collection with the name {0} was not registered.", name ) );
            }

            Argument entry = Arguments[name];
            return (T)entry.GetValue();
        }

GetValue< T >() [2/3]

T DotArgs.CommandLineArgs.GetValue< T >

(

string

name

)

Gets the value of an argument.

Parameters

name	Name of the argument to read.

Returns

The effective value of the argument. If the argument was omitted in the arguments, the default value will be returned.

Exceptions

System.Collections.Generic.KeyNotFoundException

An argument with the name name was not registered.

        {
            if( !Arguments.ContainsKey( name ) )
            {
                throw new KeyNotFoundException( string.Format( "An collection with the name {0} was not registered.", name ) );
            }

            Argument entry = Arguments[name];
            return (T)entry.GetValue();
        }

GetValue< T >() [3/3]

T DotArgs.CommandLineArgs.GetValue< T >

(

string

name

)

Gets the value of an argument.

Parameters

name	Name of the argument to read.

Returns

The effective value of the argument. If the argument was omitted in the arguments, the default value will be returned.

Exceptions

System.Collections.Generic.KeyNotFoundException

An argument with the name name was not registered.

        {
            if( !Arguments.ContainsKey( name ) )
            {
                throw new KeyNotFoundException( string.Format( "An collection with the name {0} was not registered.", name ) );
            }

            Argument entry = Arguments[name];
            return (T)entry.GetValue();
        }

PrintHelp() [1/3]

void DotArgs.CommandLineArgs.PrintHelp

(

string

errorMessage = null

)

Prints a help message describing the effects of all available options.

Parameters

errorMessage

Optional error message to display.

        {
            string argList = string.Join( " ", Arguments.OrderBy( k => k.Key ).Select( a => ArgumentToArgList( a.Key, a.Value ) ) );

            OutputWriter.WriteLine( ApplicationInfo );
            OutputWriter.WriteLine();
            if( !string.IsNullOrWhiteSpace( errorMessage ) )
            {
                OutputWriter.WriteLine( errorMessage );
                OutputWriter.WriteLine();
            }
            OutputWriter.WriteLine( "Usage:" );
            OutputWriter.WriteLine( "{0} {1}", ExecuteableName, argList );

            foreach( KeyValuePair<string, Argument> kvp in Arguments.OrderBy( k => k.Key ) )
            {
                OutputWriter.WriteLine();
                OutputWriter.WriteLine( "{0,-10}{1}", kvp.Key, kvp.Value.HelpMessage );
                OutputWriter.WriteLine( "{0,-10}{1}", "", GetArgumentInfo( kvp.Value ) );
            }

            if( Examples.Any() )
            {
                OutputWriter.WriteLine();
                OutputWriter.WriteLine( "Examples:" );

                foreach( KeyValuePair<string, string> kvp in Examples.OrderBy( k => k.Key ) )
                {
                    OutputWriter.WriteLine();
                    OutputWriter.WriteLine( kvp.Key );
                    OutputWriter.WriteLine( kvp.Value );
                }
            }
        }

PrintHelp() [2/3]

void DotArgs.CommandLineArgs.PrintHelp

(

string

errorMessage = null

)

Prints a help message describing the effects of all available options.

Parameters

errorMessage

Optional error message to display.

        {
            string argList = string.Join( " ", Arguments.OrderBy( k => k.Key ).Select( a => ArgumentToArgList( a.Key, a.Value ) ) );

            OutputWriter.WriteLine( ApplicationInfo );
            OutputWriter.WriteLine();
            if( !string.IsNullOrWhiteSpace( errorMessage ) )
            {
                OutputWriter.WriteLine( errorMessage );
                OutputWriter.WriteLine();
            }
            OutputWriter.WriteLine( "Usage:" );
            OutputWriter.WriteLine( "{0} {1}", ExecuteableName, argList );

            foreach( KeyValuePair<string, Argument> kvp in Arguments.OrderBy( k => k.Key ) )
            {
                OutputWriter.WriteLine();
                OutputWriter.WriteLine( "{0,-10}{1}", kvp.Key, kvp.Value.HelpMessage );
                OutputWriter.WriteLine( "{0,-10}{1}", "", GetArgumentInfo( kvp.Value ) );
            }

            if( Examples.Any() )
            {
                OutputWriter.WriteLine();
                OutputWriter.WriteLine( "Examples:" );

                foreach( KeyValuePair<string, string> kvp in Examples.OrderBy( k => k.Key ) )
                {
                    OutputWriter.WriteLine();
                    OutputWriter.WriteLine( kvp.Key );
                    OutputWriter.WriteLine( kvp.Value );
                }
            }
        }

PrintHelp() [3/3]

void DotArgs.CommandLineArgs.PrintHelp

(

string

errorMessage = null

)

Prints a help message describing the effects of all available options.

Parameters

errorMessage

Optional error message to display.

        {
            string argList = string.Join( " ", Arguments.OrderBy( k => k.Key ).Select( a => ArgumentToArgList( a.Key, a.Value ) ) );

            OutputWriter.WriteLine( ApplicationInfo );
            OutputWriter.WriteLine();
            if( !string.IsNullOrWhiteSpace( errorMessage ) )
            {
                OutputWriter.WriteLine( errorMessage );
                OutputWriter.WriteLine();
            }
            OutputWriter.WriteLine( "Usage:" );
            OutputWriter.WriteLine( "{0} {1}", ExecuteableName, argList );

            foreach( KeyValuePair<string, Argument> kvp in Arguments.OrderBy( k => k.Key ) )
            {
                OutputWriter.WriteLine();
                OutputWriter.WriteLine( "{0,-10}{1}", kvp.Key, kvp.Value.HelpMessage );
                OutputWriter.WriteLine( "{0,-10}{1}", "", GetArgumentInfo( kvp.Value ) );
            }

            if( Examples.Any() )
            {
                OutputWriter.WriteLine();
                OutputWriter.WriteLine( "Examples:" );

                foreach( KeyValuePair<string, string> kvp in Examples.OrderBy( k => k.Key ) )
                {
                    OutputWriter.WriteLine();
                    OutputWriter.WriteLine( kvp.Key );
                    OutputWriter.WriteLine( kvp.Value );
                }
            }
        }

Process() [1/3]

void DotArgs.CommandLineArgs.Process

(

)

Processes all registered arguments that have their Argument.Processor set.

        {
            foreach( Argument arg in Arguments.Values.Where( a => !( a is AliasArgument ) ) )
            {
                if( arg.Processor != null )
                {
                    arg.Processor( arg.GetValue() );
                }
            }
        }

Process() [2/3]

void DotArgs.CommandLineArgs.Process

(

)

Processes all registered arguments that have their Argument.Processor set.

        {
            foreach( Argument arg in Arguments.Values.Where( a => !( a is AliasArgument ) ) )
            {
                if( arg.Processor != null )
                {
                    arg.Processor( arg.GetValue() );
                }
            }
        }

Process() [3/3]

void DotArgs.CommandLineArgs.Process

(

)

Processes all registered arguments that have their Argument.Processor set.

        {
            foreach( Argument arg in Arguments.Values.Where( a => !( a is AliasArgument ) ) )
            {
                if( arg.Processor != null )
                {
                    arg.Processor( arg.GetValue() );
                }
            }
        }

RegisterAlias() [1/3]

void DotArgs.CommandLineArgs.RegisterAlias	(	string	originalName,
		string	alias
	)

Registers an alias for an existing entry.

Parameters

originalName	Name of the original option.
alias	The alias to add for the option.

Exceptions

System.Collections.Generic.KeyNotFoundException

An entry with the name originalName was not registered.

        {
            if( !Arguments.ContainsKey( originalName ) )
            {
                throw new KeyNotFoundException( string.Format( "An entry with the name {0} was not registered.", originalName ) );
            }

            AliasArgument entry = new AliasArgument( Arguments[originalName] );
            Arguments[alias] = entry;
        }

RegisterAlias() [2/3]

void DotArgs.CommandLineArgs.RegisterAlias	(	string	originalName,
		string	alias
	)

Registers an alias for an existing entry.

Parameters

originalName	Name of the original option.
alias	The alias to add for the option.

Exceptions

System.Collections.Generic.KeyNotFoundException

An entry with the name originalName was not registered.

        {
            if( !Arguments.ContainsKey( originalName ) )
            {
                throw new KeyNotFoundException( string.Format( "An entry with the name {0} was not registered.", originalName ) );
            }

            AliasArgument entry = new AliasArgument( Arguments[originalName] );
            Arguments[alias] = entry;
        }

RegisterAlias() [3/3]

void DotArgs.CommandLineArgs.RegisterAlias	(	string	originalName,
		string	alias
	)

Registers an alias for an existing entry.

Parameters

originalName	Name of the original option.
alias	The alias to add for the option.

Exceptions

System.Collections.Generic.KeyNotFoundException

An entry with the name originalName was not registered.

        {
            if( !Arguments.ContainsKey( originalName ) )
            {
                throw new KeyNotFoundException( string.Format( "An entry with the name {0} was not registered.", originalName ) );
            }

            AliasArgument entry = new AliasArgument( Arguments[originalName] );
            Arguments[alias] = entry;
        }

RegisterArgument() [1/3]

void DotArgs.CommandLineArgs.RegisterArgument	(	string	name,
		Argument	arg
	)

Registers a new argument.

Parameters

name	Name of the argument to register.
arg	The argument's configuration.

        {
            Arguments[name] = arg;
        }

RegisterArgument() [2/3]

void DotArgs.CommandLineArgs.RegisterArgument	(	string	name,
		Argument	arg
	)

Registers a new argument.

Parameters

name	Name of the argument to register.
arg	The argument's configuration.

        {
            Arguments[name] = arg;
        }

RegisterArgument() [3/3]

void DotArgs.CommandLineArgs.RegisterArgument	(	string	name,
		Argument	arg
	)

Registers a new argument.

Parameters

name	Name of the argument to register.
arg	The argument's configuration.

        {
            Arguments[name] = arg;
        }

RegisterHelpArgument() [1/3]

void DotArgs.CommandLineArgs.RegisterHelpArgument

(

string

name = "help"

)

Registers a help argument that will display the help page for the program if set by the user.

Parameters

name	Name of the flag. The default value is "help".

        {
            FlagArgument arg = new FlagArgument();
            arg.Processor = ( v ) => PrintHelp();
            arg.HelpMessage = "Displays this help.";

            RegisterArgument( name, arg );
        }

RegisterHelpArgument() [2/3]

void DotArgs.CommandLineArgs.RegisterHelpArgument

(

string

name = "help"

)

Registers a help argument that will display the help page for the program if set by the user.

Parameters

name	Name of the flag. The default value is "help".

        {
            FlagArgument arg = new FlagArgument();
            arg.Processor = ( v ) => PrintHelp();
            arg.HelpMessage = "Displays this help.";

            RegisterArgument( name, arg );
        }

RegisterHelpArgument() [3/3]

void DotArgs.CommandLineArgs.RegisterHelpArgument

(

string

name = "help"

)

Registers a help argument that will display the help page for the program if set by the user.

Parameters

name	Name of the flag. The default value is "help".

        {
            FlagArgument arg = new FlagArgument();
            arg.Processor = ( v ) => PrintHelp();
            arg.HelpMessage = "Displays this help.";

            RegisterArgument( name, arg );
        }

SetDefaultArgument() [1/3]

void DotArgs.CommandLineArgs.SetDefaultArgument

(

string

argument

)

Sets the default argument that will be filled when no argument name is given.

Parameters

argument

Name of the argument to use as the default.

        {
            if( !Arguments.ContainsKey( argument ) )
            {
                throw new ArgumentException( string.Format( "Argument {0} was not registered", argument ), "argument" );
            }

            DefaultArgument = argument;
        }

SetDefaultArgument() [2/3]

void DotArgs.CommandLineArgs.SetDefaultArgument

(

string

argument

)

Sets the default argument that will be filled when no argument name is given.

Parameters

argument

Name of the argument to use as the default.

        {
            if( !Arguments.ContainsKey( argument ) )
            {
                throw new ArgumentException( string.Format( "Argument {0} was not registered", argument ), "argument" );
            }

            DefaultArgument = argument;
        }

SetDefaultArgument() [3/3]

void DotArgs.CommandLineArgs.SetDefaultArgument

(

string

argument

)

Sets the default argument that will be filled when no argument name is given.

Parameters

argument

Name of the argument to use as the default.

        {
            if( !Arguments.ContainsKey( argument ) )
            {
                throw new ArgumentException( string.Format( "Argument {0} was not registered", argument ), "argument" );
            }

            DefaultArgument = argument;
        }

Validate() [1/6]

bool DotArgs.CommandLineArgs.Validate	(	string []	args,
		OptionalOut< string[]>	outErrors = null
	)

Processes a set of command line arguments.

Parameters

args	Command line arguments to process. This is usally coming from your Main method.
outErrors	Optional "out" parameter that holds error strings for every encountered error.

Returns

true if the arguments in args are valid; otherwise false .

        {
            return Validate( string.Join( " ", args ), outErrors );
        }

Validate() [2/6]

bool DotArgs.CommandLineArgs.Validate	(	string []	args,
		OptionalOut< string[]>	outErrors = null
	)

Processes a set of command line arguments.

Parameters

args	Command line arguments to process. This is usally coming from your Main method.
outErrors	Optional "out" parameter that holds error strings for every encountered error.

Returns

true if the arguments in args are valid; otherwise false .

        {
            return Validate( string.Join( " ", args ), outErrors );
        }

Validate() [3/6]

bool DotArgs.CommandLineArgs.Validate	(	string []	args,
		OptionalOut< string[]>	outErrors = null
	)

Processes a set of command line arguments.

Parameters

args	Command line arguments to process. This is usally coming from your Main method.
outErrors	Optional "out" parameter that holds error strings for every encountered error.

Returns

true if the arguments in args are valid; otherwise false .

        {
            return Validate( string.Join( " ", args ), outErrors );
        }

Validate() [4/6]

bool DotArgs.CommandLineArgs.Validate	(	string	args,
		OptionalOut< string[]>	outErrors = null
	)

Processes a set of command line arguments.

Parameters

args	Command line arguments to process. This is usally coming from your Main method.
outErrors	Optional "out" parameter that holds error strings for every encountered error.

Returns

true if the arguments in args are valid; otherwise false .

        {
            Reset();

            bool ignoreAlreadyHandled = false;
            if( DefaultArgument != null )
            {
                ignoreAlreadyHandled = Arguments[DefaultArgument].SupportsMultipleValues;
            }

            bool handledDefault = false;
            bool errors = false;
            List<string> errorList = new List<string>();

            List<string> parts = SplitCommandLine( args );
            for( int i = 0; i < parts.Count; ++i )
            {
                string arg = GetArgName( parts[i] );
                if( !IsArgumentName( parts[i] ) )
                {
                    if( !handledDefault || ignoreAlreadyHandled )
                    {
                        parts[i] = string.Format( "/{0}={1}", DefaultArgument, arg );
                        arg = DefaultArgument;

                        handledDefault = true;
                    }
                }

                if( !Arguments.ContainsKey( arg ) )
                {
                    if( DefaultArgument != null && ( !handledDefault || ignoreAlreadyHandled ) )
                    {
                        parts[i] = string.Format( "/{0}={1}", DefaultArgument, arg );
                        arg = DefaultArgument;

                        handledDefault = true;
                    }
                    else
                    {
                        errorList.Add( string.Format( "Unknown option: '{0}'", arg ) );

                        errors = true;
                        continue;
                    }
                }

                Argument entry = Arguments[arg];

                if( entry.NeedsValue )
                {
                    // Not so simple cases: Collection and Option
                    string value = ExtractValueFromArg( parts[i] );

                    if( value == null && i < parts.Count - 1 )
                    {
                        value = parts[i + 1];

                        if( Arguments.ContainsKey( GetArgName( value ) ) )
                        {
                            value = null;
                        }
                        else
                        {
                            i++;
                        }
                    }

                    if( value != null )
                    {
                        entry.SetValue( value );
                    }
                    else
                    {
                        // Missing argument
                        errorList.Add( string.Format( "Missing value for option '{0}'", arg ) );
                        errors = true;
                    }
                }
                else // Simple case: a flag
                {
                    entry.SetValue( true );
                }
            }

            foreach( KeyValuePair<string, Argument> kvp in Arguments )
            {
                Argument entry = kvp.Value;
                object value = entry.GetValue();

                if( entry.IsRequired && value == null )
                {
                    errorList.Add( string.Format( "Missing value for option '{0}'", kvp.Key ) );
                    errors = true;
                }

                if( !entry.Validate( value ) )
                {
                    errorList.Add( string.Format( "{0}: Invalid value {1}", kvp.Key, value ) );
                    errors = true;
                }
            }

            if( outErrors != null )
            {
                outErrors.Result = errorList.Distinct().ToArray();
            }

            return !errors;
        }

Validate() [5/6]

bool DotArgs.CommandLineArgs.Validate	(	string	args,
		OptionalOut< string[]>	outErrors = null
	)

Processes a set of command line arguments.

Parameters

args	Command line arguments to process. This is usally coming from your Main method.
outErrors	Optional "out" parameter that holds error strings for every encountered error.

Returns

true if the arguments in args are valid; otherwise false .

        {
            Reset();

            bool ignoreAlreadyHandled = false;
            if( DefaultArgument != null )
            {
                ignoreAlreadyHandled = Arguments[DefaultArgument].SupportsMultipleValues;
            }

            bool handledDefault = false;
            bool errors = false;
            List<string> errorList = new List<string>();

            List<string> parts = SplitCommandLine( args );
            for( int i = 0; i < parts.Count; ++i )
            {
                string arg = GetArgName( parts[i] );
                if( !IsArgumentName( parts[i] ) )
                {
                    if( !handledDefault || ignoreAlreadyHandled )
                    {
                        parts[i] = string.Format( "/{0}={1}", DefaultArgument, arg );
                        arg = DefaultArgument;

                        handledDefault = true;
                    }
                }

                if( !Arguments.ContainsKey( arg ) )
                {
                    if( DefaultArgument != null && ( !handledDefault || ignoreAlreadyHandled ) )
                    {
                        parts[i] = string.Format( "/{0}={1}", DefaultArgument, arg );
                        arg = DefaultArgument;

                        handledDefault = true;
                    }
                    else
                    {
                        errorList.Add( string.Format( "Unknown option: '{0}'", arg ) );

                        errors = true;
                        continue;
                    }
                }

                Argument entry = Arguments[arg];

                if( entry.NeedsValue )
                {
                    // Not so simple cases: Collection and Option
                    string value = ExtractValueFromArg( parts[i] );

                    if( value == null && i < parts.Count - 1 )
                    {
                        value = parts[i + 1];

                        if( Arguments.ContainsKey( GetArgName( value ) ) )
                        {
                            value = null;
                        }
                        else
                        {
                            i++;
                        }
                    }

                    if( value != null )
                    {
                        entry.SetValue( value );
                    }
                    else
                    {
                        // Missing argument
                        errorList.Add( string.Format( "Missing value for option '{0}'", arg ) );
                        errors = true;
                    }
                }
                else // Simple case: a flag
                {
                    entry.SetValue( true );
                }
            }

            foreach( KeyValuePair<string, Argument> kvp in Arguments )
            {
                Argument entry = kvp.Value;
                object value = entry.GetValue();

                if( entry.IsRequired && value == null )
                {
                    errorList.Add( string.Format( "Missing value for option '{0}'", kvp.Key ) );
                    errors = true;
                }

                if( !entry.Validate( value ) )
                {
                    errorList.Add( string.Format( "{0}: Invalid value {1}", kvp.Key, value ) );
                    errors = true;
                }
            }

            if( outErrors != null )
            {
                outErrors.Result = errorList.Distinct().ToArray();
            }

            return !errors;
        }

Validate() [6/6]

bool DotArgs.CommandLineArgs.Validate	(	string	args,
		OptionalOut< string[]>	outErrors = null
	)

Processes a set of command line arguments.

Parameters

args	Command line arguments to process. This is usally coming from your Main method.
outErrors	Optional "out" parameter that holds error strings for every encountered error.

Returns

true if the arguments in args are valid; otherwise false .

        {
            Reset();

            bool ignoreAlreadyHandled = false;
            if( DefaultArgument != null )
            {
                ignoreAlreadyHandled = Arguments[DefaultArgument].SupportsMultipleValues;
            }

            bool handledDefault = false;
            bool errors = false;
            List<string> errorList = new List<string>();

            List<string> parts = SplitCommandLine( args );
            for( int i = 0; i < parts.Count; ++i )
            {
                string arg = GetArgName( parts[i] );
                if( !IsArgumentName( parts[i] ) )
                {
                    if( !handledDefault || ignoreAlreadyHandled )
                    {
                        parts[i] = string.Format( "/{0}={1}", DefaultArgument, arg );
                        arg = DefaultArgument;

                        handledDefault = true;
                    }
                }

                if( !Arguments.ContainsKey( arg ) )
                {
                    if( DefaultArgument != null && ( !handledDefault || ignoreAlreadyHandled ) )
                    {
                        parts[i] = string.Format( "/{0}={1}", DefaultArgument, arg );
                        arg = DefaultArgument;

                        handledDefault = true;
                    }
                    else
                    {
                        errorList.Add( string.Format( "Unknown option: '{0}'", arg ) );

                        errors = true;
                        continue;
                    }
                }

                Argument entry = Arguments[arg];

                if( entry.NeedsValue )
                {
                    // Not so simple cases: Collection and Option
                    string value = ExtractValueFromArg( parts[i] );

                    if( value == null && i < parts.Count - 1 )
                    {
                        value = parts[i + 1];

                        if( Arguments.ContainsKey( GetArgName( value ) ) )
                        {
                            value = null;
                        }
                        else
                        {
                            i++;
                        }
                    }

                    if( value != null )
                    {
                        entry.SetValue( value );
                    }
                    else
                    {
                        // Missing argument
                        errorList.Add( string.Format( "Missing value for option '{0}'", arg ) );
                        errors = true;
                    }
                }
                else // Simple case: a flag
                {
                    entry.SetValue( true );
                }
            }

            foreach( KeyValuePair<string, Argument> kvp in Arguments )
            {
                Argument entry = kvp.Value;
                object value = entry.GetValue();

                if( entry.IsRequired && value == null )
                {
                    errorList.Add( string.Format( "Missing value for option '{0}'", kvp.Key ) );
                    errors = true;
                }

                if( !entry.Validate( value ) )
                {
                    errorList.Add( string.Format( "{0}: Invalid value {1}", kvp.Key, value ) );
                    errors = true;
                }
            }

            if( outErrors != null )
            {
                outErrors.Result = errorList.Distinct().ToArray();
            }

            return !errors;
        }

Property Documentation

ApplicationInfo

string DotArgs.CommandLineArgs.ApplicationInfo

getset

Information about the application that will be displayed in the usage page.

MyCoolProgram v1.2 Copyright (C) John Smith <smith.nosp@m.@exa.nosp@m.mple..nosp@m.com>

ExecuteableName

string DotArgs.CommandLineArgs.ExecuteableName

getset

Name of the executeable that will be displayed in the usage page.

The default value for this is the name of the assembly containing the code that created this object.

OutputWriter

TextWriter DotArgs.CommandLineArgs.OutputWriter

getset

The TextWriter that is used to write the output. The default value is to use Console.Out

---

The documentation for this class was generated from the following file:

• src/packages/DotArgs.1.0.0/content/CommandLineArgs.cs