static void Main(string[] args)
{
int rate = 300;
long loggingSteps = 50;
int parameterLength = -1;
string outputFile = "";
CommandLine.ParserResult <Options> result = CommandLine.Parser.Default.ParseArguments <Options>(args);
if (result.Tag == CommandLine.ParserResultType.Parsed)
{
var parsed = (CommandLine.Parsed <Options>)result;
rate = Convert.ToInt32(parsed.Value.Rate);
loggingSteps = Convert.ToInt64(parsed.Value.TotalSeconds);
parameterLength = parsed.Value.ParameterLength;
outputFile = parsed.Value.OutputFile;
Console.WriteLine("rate: {0}", rate);
Console.WriteLine("loggingSteps: {0}", loggingSteps);
Console.WriteLine("parameterLength: {0}", parameterLength);
Console.WriteLine("outputFile: {0}", outputFile);
DoBenchMark(rate, loggingSteps, parameterLength, outputFile);
}
else
{
Console.WriteLine("\nPlease check correct arguments!");
}
}
/// <summary>
/// Analyses the command line arguments.
/// </summary>
static public void CheckCommandLineArguments <T>(string[] args, ref Language language)
where T : SystemCommandLine
{
try
{
CommandLineArguments = args;
CommandLine.ParserResult <T> options = CommandLine.Parser.Default.ParseArguments <T>(args);
if (options.Tag != CommandLine.ParserResultType.Parsed)
{
return;
}
CommandLineOptions = ((CommandLine.Parsed <T>)options).Value;
if (!CommandLineOptions.Language.IsNullOrEmpty())
{
foreach (var lang in Languages.Values)
{
if (CommandLineOptions.Language.ToLower() == lang.Key)
{
language = lang.Value;
}
}
}
}
catch (Exception ex)
{
ex.Manage();
}
}
/// <summary>
/// Informs the user that used wrong arguments
/// </summary>
/// <param name="options">The benchmark options to be used</param>
protected virtual void PrintWrongArgumentsHelp(CommandLine.ParserResult <BenchmarkOptions> options)
{
PrintErrorLog("You are using me wrongly.");
Log.WriteLine("The correct usage is as follows:");
var helpText = CommandLine.Text.HelpText.AutoBuild(options);
Log.WriteLine(helpText.ToString());
}
/// <summary>
/// Print the CommandLine help.
/// </summary>
/// <param name="parser">Parser used (CommandLine).</param>
/// <param name="errs">Error list.</param>
/// <param name="argv">argv list.</param>
/// <typeparam name="T">The generic type parameter: Object to parser to get the usage.</typeparam>
/// <returns>String usage.</returns>
public string PrintHelp <T>(CommandLine.ParserResult <T> parser, System.Collections.Generic.IEnumerable <CommandLine.Error> errs, string[] argv)
{
// create logs if not already created
CLILogs.CreateLoggers();
string helpText = PrintHelpErrorUsage(parser);
ParseException ex = new ParseException();
// check if a "help" flag is used
if (argv.Length > 1 && argv[1] == "help")
{
CLILogs.Usage(PrintHelpUsage(parser));
throw new ParseHelpException();
}
if (errs == null)
{
CLILogs.Usage(helpText);
throw ex;
}
if (errs.Any(x => x.Tag == CommandLine.ErrorType.VersionRequestedError))
{
helpText = PrintHelpVersion(parser);
ex = new ParseVersionException();
}
else if (errs.Any(x => x.Tag == CommandLine.ErrorType.HelpRequestedError))
{
helpText = PrintHelpUsage(parser);
ex = new ParseHelpException();
}
else if (errs.Any(x => x.Tag == CommandLine.ErrorType.HelpVerbRequestedError))
{
helpText = PrintHelpVerbUsage(parser);
ex = new ParseHelpException();
}
else if (errs.Any(x => x.Tag == CommandLine.ErrorType.NoVerbSelectedError ||
x.Tag == CommandLine.ErrorType.BadVerbSelectedError))
{
helpText = PrintHelpErrorVerbUsage(parser);
string errorList = string.Empty;
errs.ToList().ForEach(e => errorList += e.ToString());
ex = new ParseException(errorList);
CLILogs.Debug("Parsing error : " + errorList);
}
else
{
string errorList = string.Empty;
errs.ToList().ForEach(e => errorList += e.ToString());
ex = new ParseException(errorList);
CLILogs.Debug("Parsing error : " + errorList);
}
CLILogs.Usage(helpText);
throw ex;
}
private string PrintHelpVerbUsage <T>(CommandLine.ParserResult <T> parser)
{
string help = CommandLine.Text.HelpText.AutoBuild(parser, h =>
{
h.Heading = PrintHelpVersion(parser);
return(CommandLine.Text.HelpText.DefaultParsingErrorsHandler(parser, h));
},
e => e, true, ParserUsage.maxSize);
return(help);
}
private string PrintHelpVersion <T>(CommandLine.ParserResult <T> parser)
{
string assemblyName = AssemblyAttributes.AssemblyName;
string assemblyVersion = AssemblyAttributes.AssemblyVersion;
string gitHash = AssemblyAttributes.CommitHash;
string frameWorkBuilder = AssemblyAttributes.FrameworkName.Replace(" ", String.Empty);
string date = AssemblyAttributes.BuildDate;
// Remove milliseconds from the timestamp
date = date.Substring(0, date.Length - 5) + "Z";
return(String.Format("{0}-{1}-{2}-{3}-{4}", assemblyName, assemblyVersion, gitHash, date, frameWorkBuilder));
}
private string PrintHelpErrorUsage <T>(CommandLine.ParserResult <T> parser)
{
return(CommandLine.Text.HelpText.AutoBuild(
parser,
h =>
{
h.AddDashesToOption = true;
h.AddEnumValuesToHelpText = true;
return CommandLine.Text.HelpText.DefaultParsingErrorsHandler(parser, h);
},
e => e,
false,
ParserUsage.maxSize));
}
static void Main(string[] args)
{
long loggingSteps = 50;
CommandLine.ParserResult <Options> result = CommandLine.Parser.Default.ParseArguments <Options>(args);
if (result.Tag == CommandLine.ParserResultType.Parsed)
{
var parsed = (CommandLine.Parsed <Options>)result;
loggingSteps = Convert.ToInt64(parsed.Value.TotalSeconds);
Console.WriteLine("loggingSteps: {0}", loggingSteps);
DoMonitor(loggingSteps);
}
else
{
Console.WriteLine("\nPlease check correct arguments!");
}
}
private string PrintHelpErrorVerbUsage <T>(CommandLine.ParserResult <T> parser)
{
return(CommandLine.Text.HelpText.AutoBuild(parser, h => { return CommandLine.Text.HelpText.DefaultParsingErrorsHandler(parser, h); }, e => e, true, ParserUsage.maxSize));
}
