构建带有参数的控制台应用程序时,可以使用传递给的参数Main(string[] args)
。
过去,我只是索引/循环该数组,并做了一些正则表达式来提取值。但是,当命令变得更复杂时,解析可能会变得很丑陋。
所以我对以下内容感兴趣:
- 您使用的库
- 您使用的模式
假定命令始终遵循通用标准,例如此处回答。
构建带有参数的控制台应用程序时,可以使用传递给的参数Main(string[] args)
。
过去,我只是索引/循环该数组,并做了一些正则表达式来提取值。但是,当命令变得更复杂时,解析可能会变得很丑陋。
所以我对以下内容感兴趣:
假定命令始终遵循通用标准,例如此处回答。
Answers:
我强烈建议使用NDesk.Options(文档)和/或Mono.Options(相同的API,不同的名称空间)。文档中的示例:
bool show_help = false;
List<string> names = new List<string> ();
int repeat = 1;
var p = new OptionSet () {
{ "n|name=", "the {NAME} of someone to greet.",
v => names.Add (v) },
{ "r|repeat=",
"the number of {TIMES} to repeat the greeting.\n" +
"this must be an integer.",
(int v) => repeat = v },
{ "v", "increase debug message verbosity",
v => { if (v != null) ++verbosity; } },
{ "h|help", "show this message and exit",
v => show_help = v != null },
};
List<string> extra;
try {
extra = p.Parse (args);
}
catch (OptionException e) {
Console.Write ("greet: ");
Console.WriteLine (e.Message);
Console.WriteLine ("Try `greet --help' for more information.");
return;
}
git checkout master
),或者它们的参数不灵活(即,不支持--foo 123
= --foo=123
= -f 123
= -f=123
和-v -h
= -vh
)。
我真的很喜欢命令行解析器库(http://commandline.codeplex.com/)。它具有通过属性设置参数的非常简单而优雅的方法:
class Options
{
[Option("i", "input", Required = true, HelpText = "Input file to read.")]
public string InputFile { get; set; }
[Option(null, "length", HelpText = "The maximum number of bytes to process.")]
public int MaximumLenght { get; set; }
[Option("v", null, HelpText = "Print details during execution.")]
public bool Verbose { get; set; }
[HelpOption(HelpText = "Display this help screen.")]
public string GetUsage()
{
var usage = new StringBuilder();
usage.AppendLine("Quickstart Application 1.0");
usage.AppendLine("Read user manual for usage instructions...");
return usage.ToString();
}
}
--recursive
。
在WPF TestApi库配备了最好的命令行解析器C#开发的一个。我强烈建议您从Ivo Manolov的API博客中进行调查:
// EXAMPLE #2:
// Sample for parsing the following command-line:
// Test.exe /verbose /runId=10
// This sample declares a class in which the strongly-
// typed arguments are populated
public class CommandLineArguments
{
bool? Verbose { get; set; }
int? RunId { get; set; }
}
CommandLineArguments a = new CommandLineArguments();
CommandLineParser.ParseArguments(args, a);
看起来每个人都有自己的宠物命令行解析器,我最好也添加我的:)。
该库包含一个命令行解析器,它将使用命令行中的值初始化一个类。它具有大量功能(多年来我一直在构建它)。
从文档中 ...
BizArk框架中的命令行分析具有以下关键功能:
我不久前写了一个C#命令行参数解析器。它位于:http : //www.codeplex.com/CommandLineArguments
CLAP(命令行参数解析器)具有可用的API,并且文档详尽。您可以制作一个方法,并为参数添加注释。 https://github.com/adrianaisemberg/CLAP
myapp myverb -argname argvalue
必须-argname
)或myapp -help
(通常--help
)。
有许多解决此问题的方法。为了完整性和提供替代方案,如果有人希望我在我的谷歌代码库中为两个有用的类添加答案。
第一个是ArgumentList,它仅负责解析命令行参数。它收集由开关“ / x:y”或“ -x = y”定义的名称/值对,并收集“未命名”条目的列表。它的基本用法是这里讨论,在这里查看类。
第二部分是CommandInterpreter,它从.Net类中创建一个功能齐全的命令行应用程序。举个例子:
using CSharpTest.Net.Commands;
static class Program
{
static void Main(string[] args)
{
new CommandInterpreter(new Commands()).Run(args);
}
//example ‘Commands’ class:
class Commands
{
public int SomeValue { get; set; }
public void DoSomething(string svalue, int ivalue)
{ ... }
使用上面的示例代码,您可以运行以下代码:
Program.exe DoSomething“字符串值” 5
- 要么 -
Program.exe处理/ ivalue = 5 -svalue:“字符串值”
我喜欢那个,因为您可以为参数“定义规则”,无论是否需要,...
或者,如果您是Unix的人,那么您可能会喜欢GNU Getopt .NET端口。
你可能喜欢我的 地毯
易于使用且可扩展的命令行参数解析器。句柄:布尔,加号/减号,字符串,字符串列表,CSV,枚举。
内建'/?' 帮助模式。
内建'/ ??' 和'/?D'文档生成器模式。
static void Main(string[] args)
{
// create the argument parser
ArgumentParser parser = new ArgumentParser("ArgumentExample", "Example of argument parsing");
// create the argument for a string
StringArgument StringArg = new StringArgument("String", "Example string argument", "This argument demonstrates string arguments");
// add the argument to the parser
parser.Add("/", "String", StringArg);
// parse arguemnts
parser.Parse(args);
// did the parser detect a /? argument
if (parser.HelpMode == false)
{
// was the string argument defined
if (StringArg.Defined == true)
{
// write its value
RC.WriteLine("String argument was defined");
RC.WriteLine(StringArg.Value);
}
}
}
编辑:这是我的项目,因此,此答案不应被视为第三方的认可。就是说,我确实将它用于我编写的每个基于命令行的程序,它是开源的,我希望其他人可以从中受益。
在以下位置有一个命令行参数解析器 http://www.codeplex.com/commonlibrarynet上
它可以使用
1.属性
2.显式调用来解析参数
3.多个参数的单行或字符串数组
它可以处理以下内容:
- 配置:QA - STARTDATE:$ { 今天 } - 区域: '纽约' Settings01
它很容易使用。
这是我基于Novell Options
类编写的处理程序。
这是针对执行以下操作的控制台应用程序 while (input !="exit")
样式循环的例如交互式控制台,例如FTP控制台。
用法示例:
static void Main(string[] args)
{
// Setup
CommandHandler handler = new CommandHandler();
CommandOptions options = new CommandOptions();
// Add some commands. Use the v syntax for passing arguments
options.Add("show", handler.Show)
.Add("connect", v => handler.Connect(v))
.Add("dir", handler.Dir);
// Read lines
System.Console.Write(">");
string input = System.Console.ReadLine();
while (input != "quit" && input != "exit")
{
if (input == "cls" || input == "clear")
{
System.Console.Clear();
}
else
{
if (!string.IsNullOrEmpty(input))
{
if (options.Parse(input))
{
System.Console.WriteLine(handler.OutputMessage);
}
else
{
System.Console.WriteLine("I didn't understand that command");
}
}
}
System.Console.Write(">");
input = System.Console.ReadLine();
}
}
以及来源:
/// <summary>
/// A class for parsing commands inside a tool. Based on Novell Options class (http://www.ndesk.org/Options).
/// </summary>
public class CommandOptions
{
private Dictionary<string, Action<string[]>> _actions;
private Dictionary<string, Action> _actionsNoParams;
/// <summary>
/// Initializes a new instance of the <see cref="CommandOptions"/> class.
/// </summary>
public CommandOptions()
{
_actions = new Dictionary<string, Action<string[]>>();
_actionsNoParams = new Dictionary<string, Action>();
}
/// <summary>
/// Adds a command option and an action to perform when the command is found.
/// </summary>
/// <param name="name">The name of the command.</param>
/// <param name="action">An action delegate</param>
/// <returns>The current CommandOptions instance.</returns>
public CommandOptions Add(string name, Action action)
{
_actionsNoParams.Add(name, action);
return this;
}
/// <summary>
/// Adds a command option and an action (with parameter) to perform when the command is found.
/// </summary>
/// <param name="name">The name of the command.</param>
/// <param name="action">An action delegate that has one parameter - string[] args.</param>
/// <returns>The current CommandOptions instance.</returns>
public CommandOptions Add(string name, Action<string[]> action)
{
_actions.Add(name, action);
return this;
}
/// <summary>
/// Parses the text command and calls any actions associated with the command.
/// </summary>
/// <param name="command">The text command, e.g "show databases"</param>
public bool Parse(string command)
{
if (command.IndexOf(" ") == -1)
{
// No params
foreach (string key in _actionsNoParams.Keys)
{
if (command == key)
{
_actionsNoParams[key].Invoke();
return true;
}
}
}
else
{
// Params
foreach (string key in _actions.Keys)
{
if (command.StartsWith(key) && command.Length > key.Length)
{
string options = command.Substring(key.Length);
options = options.Trim();
string[] parts = options.Split(' ');
_actions[key].Invoke(parts);
return true;
}
}
}
return false;
}
}
我个人最喜欢的是Peter Palotas的http://www.codeproject.com/KB/recipes/plossum_commandline.aspx:
[CommandLineManager(ApplicationName="Hello World",
Copyright="Copyright (c) Peter Palotas")]
class Options
{
[CommandLineOption(Description="Displays this help text")]
public bool Help = false;
[CommandLineOption(Description = "Specifies the input file", MinOccurs=1)]
public string Name
{
get { return mName; }
set
{
if (String.IsNullOrEmpty(value))
throw new InvalidOptionValueException(
"The name must not be empty", false);
mName = value;
}
}
private string mName;
}
我最近遇到了我非常喜欢的FubuCore命令行解析实现,原因是:
以下是有关如何使用此功能的简单示例。为了说明这种用法,我编写了一个简单的实用程序,其中包含两个命令:-添加(将对象添加到列表中-对象由名称(字符串),值(int)和布尔值标志组成)-列表(列表所有当前添加的对象)
首先,我为“ add”命令编写了一个Command类:
[Usage("add", "Adds an object to the list")]
[CommandDescription("Add object", Name = "add")]
public class AddCommand : FubuCommand<CommandInput>
{
public override bool Execute(CommandInput input)
{
State.Objects.Add(input); // add the new object to an in-memory collection
return true;
}
}
此命令将CommandInput实例作为参数,因此接下来我将其定义为:
public class CommandInput
{
[RequiredUsage("add"), Description("The name of the object to add")]
public string ObjectName { get; set; }
[ValidUsage("add")]
[Description("The value of the object to add")]
public int ObjectValue { get; set; }
[Description("Multiply the value by -1")]
[ValidUsage("add")]
[FlagAlias("nv")]
public bool NegateValueFlag { get; set; }
}
下一个命令是“列表”,其实现方式如下:
[Usage("list", "List the objects we have so far")]
[CommandDescription("List objects", Name = "list")]
public class ListCommand : FubuCommand<NullInput>
{
public override bool Execute(NullInput input)
{
State.Objects.ForEach(Console.WriteLine);
return false;
}
}
'list'命令不带任何参数,因此我为此定义了一个NullInput类:
public class NullInput { }
现在剩下的就是将它连接到Main()方法中,如下所示:
static void Main(string[] args)
{
var factory = new CommandFactory();
factory.RegisterCommands(typeof(Program).Assembly);
var executor = new CommandExecutor(factory);
executor.Execute(args);
}
该程序将按预期工作,在任何命令无效的情况下会打印有关正确用法的提示:
------------------------
Available commands:
------------------------
add -> Add object
list -> List objects
------------------------
以及“ add”命令的示例用法:
Usages for 'add' (Add object)
add <objectname> [-nv]
-------------------------------------------------
Arguments
-------------------------------------------------
objectname -> The name of the object to add
objectvalue -> The value of the object to add
-------------------------------------------------
-------------------------------------
Flags
-------------------------------------
[-nv] -> Multiply the value by -1
-------------------------------------
Powershell Commandlet。
Powershell会根据命令行小程序上指定的属性进行解析,支持验证,参数集,流水线,错误报告,帮助,以及所有返回的.NET对象中最好的供其他命令行小程序使用的对象。
我发现几个链接对入门很有帮助:
Genghis Command Line Parser 可能有点过时了,但是功能非常完整,对我来说效果很好。
我建议使用开源库CSharpOptParse。它解析命令行,并使用命令行输入合并用户定义的.NET对象。在编写C#控制台应用程序时,我总是转向该库。
一个非常简单易用的临时类,用于命令行解析,它支持默认参数。
class CommandLineArgs
{
public static CommandLineArgs I
{
get
{
return m_instance;
}
}
public string argAsString( string argName )
{
if (m_args.ContainsKey(argName)) {
return m_args[argName];
}
else return "";
}
public long argAsLong(string argName)
{
if (m_args.ContainsKey(argName))
{
return Convert.ToInt64(m_args[argName]);
}
else return 0;
}
public double argAsDouble(string argName)
{
if (m_args.ContainsKey(argName))
{
return Convert.ToDouble(m_args[argName]);
}
else return 0;
}
public void parseArgs(string[] args, string defaultArgs )
{
m_args = new Dictionary<string, string>();
parseDefaults(defaultArgs );
foreach (string arg in args)
{
string[] words = arg.Split('=');
m_args[words[0]] = words[1];
}
}
private void parseDefaults(string defaultArgs )
{
if ( defaultArgs == "" ) return;
string[] args = defaultArgs.Split(';');
foreach (string arg in args)
{
string[] words = arg.Split('=');
m_args[words[0]] = words[1];
}
}
private Dictionary<string, string> m_args = null;
static readonly CommandLineArgs m_instance = new CommandLineArgs();
}
class Program
{
static void Main(string[] args)
{
CommandLineArgs.I.parseArgs(args, "myStringArg=defaultVal;someLong=12");
Console.WriteLine("Arg myStringArg : '{0}' ", CommandLineArgs.I.argAsString("myStringArg"));
Console.WriteLine("Arg someLong : '{0}' ", CommandLineArgs.I.argAsLong("someLong"));
}
}