Question

我正在使用命令行参数，如果条件用于检查输入值但看起来不太好我可以将其更改为切换但我不知道如何更改它我的代码是

if (args.Length > 0 && args.Length == 4)
{
    string programName = args[0];
    string file1= args[2];
    string file2= args[3];

    bool flag = false;
    int num= 0;
    bool isNum = Int32.TryParse(args[1].ToString(), out num);

    if (!(programName.Equals("Army")))
    {
        Console.WriteLine("Error"); 
    }

    if (!Int32.TryParse(args[1].ToString(), out isNum ))
    {
        Console.WriteLine("value should be a number");
    }

    if (!File.Exists(file1))
    {
        Console.WriteLine("file 1 does not exist");
    }
    if (!File.Exists(file2))
    {
        Console.WriteLine("file 2 does not exist");
    }

Answer 1

此处并未真正调用switch语句。当您拥有单个值并且需要根据该值从一系列可能的互斥步骤中进行选择时，这非常有用。但那不是你在这里做的。这些不是一串if/else if语句，它们更像是一个值，它们更像是一个守护条款。所有这些都需要运行才能确定要向用户显示的所有输出。

您可以通过删除大括号来缩短代码：

if (!(programName.Equals("Army")))
    Console.WriteLine("Error"); 
if (!Int32.TryParse(args[1].ToString(), out isNum ))
    Console.WriteLine("value should be a number");
if (!File.Exists(file1))
    Console.WriteLine("file 1 does not exist");
if (!File.Exists(file2))
    Console.WriteLine("file 2 does not exist");

您还可以将这些代码行提取到自己的方法中，这会使Main方法更清晰一些。您甚至可以将条件检查本身提取到非常小的方法中，使其更具散文性，以便于阅读。但条件结构本身并不需要改变。

Answer 2

您可以创建负责检索和检查应用程序参数的类。例如。如果您的应用程序名称为Zorg，则可以创建以下类：

public class ZorgConfiguration
{        
    private string num;
    private string programName;
    private string file1;
    private string file2;

    public static ZorgConfiguration InitializeFrom(string[] args)
    {
        if (args.Length < 4)
           throw new ZorgConfigurationException("At least 4 arguments required");

        return new ZorgConfiguration {
            ProgramName = args[0],
            Num = args[1],
            File1 = args[2],
            File2 = args[3]
        };
    }

    // to be continued
}

如您所见，它的职责是保持应用程序设置。它具有静态方法，用于从args数组创建配置实例。此方法检查参数计数是否正确，然后使用适当的参数初始化配置类的每个属性。检查参数值是否已移至属性：

public string ProgramName
{
    get { return programName; }
    private set {
        if (value == "Army")
            throw new ZorgConfigurationException("Error");
        programName = value;
    }
}

public string Num
{
    get { return num; }
    private set {
        int i;
        if (!Int32.TryParse(value, out i))
            throw new ZorgConfigurationException("value should be a number");
        num = value;
    }
}

public string File1 
{
    get { return file1; }
    private set {
        if (!File.Exists(value))
            throw new ZorgConfigurationException("file 1 does not exist");
        file1 = value;
    }         
}

每个属性都负责验证相应的参数值。如果值不正确，则抛出自定义ZorgConfigurationException（这只是继承自Exception的类）。

现在主应用程序代码看起来很干净：

try
{
    var config = ZorgConfiguration.InitializeFrom(args);
    // you can use config.File1 etc
}
catch (ZorgConfigurationException e)
{
    Console.WriteLine(e.Message);
    // exit application
}

Answer 3

我使用这个类来解析命令行参数，我发现它在某处，但我不记得在哪里：

公共类参数 { //变量 private StringDictionary参数;

    // Constructor
    public Arguments(string[] Args)
    {
        Parameters = new StringDictionary();
        Regex Spliter = new Regex(@"^-{1,2}|^/|=|:",
            RegexOptions.IgnoreCase | RegexOptions.Compiled);

        Regex Remover = new Regex(@"^['""]?(.*?)['""]?$",
            RegexOptions.IgnoreCase | RegexOptions.Compiled);

        string Parameter = null;
        string[] Parts;

        // Valid parameters forms:
        // {-,/,--}param{ ,=,:}((",')value(",'))
        // Examples: 
        // -param1 value1 --param2 /param3:"Test-:-work" 
        //   /param4=happy -param5 '--=nice=--'
        foreach (string Txt in Args)
        {
            // Look for new parameters (-,/ or --) and a
            // possible enclosed value (=,:)
            Parts = Spliter.Split(Txt, 3);

            switch (Parts.Length)
            {
                // Found a value (for the last parameter 
                // found (space separator))
                case 1:
                    if (Parameter != null)
                    {
                        if (!Parameters.ContainsKey(Parameter))
                        {
                            Parts[0] =
                                Remover.Replace(Parts[0], "$1");

                            Parameters.Add(Parameter, Parts[0]);
                        }
                        Parameter = null;
                    }
                    // else Error: no parameter waiting for a value (skipped)
                    break;

                // Found just a parameter
                case 2:
                    // The last parameter is still waiting. 
                    // With no value, set it to true.
                    if (Parameter != null)
                    {
                        if (!Parameters.ContainsKey(Parameter))
                            Parameters.Add(Parameter, "true");
                    }
                    Parameter = Parts[1];
                    break;

                // Parameter with enclosed value
                case 3:
                    // The last parameter is still waiting. 
                    // With no value, set it to true.
                    if (Parameter != null)
                    {
                        if (!Parameters.ContainsKey(Parameter))
                            Parameters.Add(Parameter, "true");
                    }

                    Parameter = Parts[1];

                    // Remove possible enclosing characters (",')
                    if (!Parameters.ContainsKey(Parameter))
                    {
                        Parts[2] = Remover.Replace(Parts[2], "$1");
                        Parameters.Add(Parameter, Parts[2]);
                    }

                    Parameter = null;
                    break;
            }
        }
        // In case a parameter is still waiting
        if (Parameter != null)
        {
            if (!Parameters.ContainsKey(Parameter))
                Parameters.Add(Parameter, "true");
        }
    }

    // Retrieve a parameter value if it exists 
    // (overriding C# indexer property)
    public string this[string Param]
    {
        get
        {
            return (Parameters[Param]);
        }
    }
}

我这样使用它：

var cmdParams = new Arguments（args）;

if（cmdParams [“File”]！= null＆amp;＆amp; parametros [“cmdParams”] ==“Filename.txt）{}

希望它有所帮助！

Answer 4

如果有不同的函数和参数，命令行参数会变得复杂。

最好的方法是标记你的参数，函数开关示例是/ p / a，或-h，-g等...你的cmd arg解析器查找这些标记（模式） - 一旦发现你知道它是哪个cmd ..有开关 - 案例或任何其他机制。还标记其他数据参数。因此，您有两组参数 - 易于管理。

检查输入值的命令行参数

4 个答案: