// @nuget: CommandLineParser -Version 2.6.0

​

using System;

using System.Text;

using System.Collections.Generic;

using CommandLine;

using CommandLine.Text;

using System.Linq;

using System.Threading.Tasks;

​

public class Program

{

    public static void Main()

    {

        var text="-r f1 -i";   

       var args = text.Split();

        Program2.Main1(args);

    }   

​

}   

​

  class Program2

    {

        private static readonly HeadingInfo HeadingInfo = new HeadingInfo("sampleapp", "1.8");

​

        /// <summary>

        /// Application's Entry Point.

        /// </summary>

        /// <param name="args">Command line arguments splitted by the system.</param>

        public  static void Main1(string[] args)

        {

​

            var options = new Options();

            var parser = new CommandLine.Parser(with => with.HelpWriter = Console.Error);

//@@ rewrite 

           // if (parser.ParseArgumentsStrict(args, options, () => Environment.Exit(-2)))

            // if (parser.ParseArgumentsStrict(args, options, () => Environment.Exit(-2)))

           // {

            //    Run(options);

           // }

     CommandLine.Parser.Default.ParseArguments<Options>(args)

         .WithParsed<Options> (o=> Run(o))

         .WithNotParsed<Options> (errors=> HandleParseError(errors));

        }

//@@ return int

        private static void Run(Options options)

        {

            if (options.VerboseLevel == null)

            {

                Console.WriteLine("verbose [off]");

            }

            else

            {

                Console.WriteLine(

                    "verbose [on]: {0}",

                    options.VerboseLevel < 0 || options.VerboseLevel > 2 ? "#invalid value#" : options.VerboseLevel.ToString());

            }

​

            Console.WriteLine();

            Console.WriteLine("input file: {0} ...", options.InputFile);

​

            foreach (string defFile in options.DefinitionFiles)

            {

                Console.WriteLine("  using definition file: {0}", defFile);

            }

​

            Console.WriteLine("  start offset: {0}", options.StartOffset);

            Console.WriteLine("  tabular data computation: {0}", options.Calculate.ToString().ToLowerInvariant());

            Console.WriteLine("  on errors: {0}", options.IgnoreErrors ? "continue" : "stop processing");

            Console.WriteLine("  optimize for: {0}", options.Optimization.ToString().ToLowerInvariant());

​

            if (options.AllowedOperators != null)

            {

                var builder = new StringBuilder();

                builder.Append("  allowed operators: ");

​

                foreach (string op in options.AllowedOperators)

                {

                    builder.Append(op);

                    builder.Append(", ");

                }

​

                Console.WriteLine(builder.Remove(builder.Length - 2, 2).ToString());

            }

​

            Console.WriteLine();

​

            if (!string.IsNullOrEmpty(options.OutputFile))

            {

                HeadingInfo.WriteMessage(string.Format("writing elaborated data: {0} ...", options.OutputFile));

            }

            else

            {

                HeadingInfo.WriteMessage("elaborated data:");

                Console.WriteLine("[...]");

            }

        }

       private static void HandleParseError(IEnumerable<Error> errors)

      {

           Console.WriteLine("HandleErrors");

      }

}

​

 public enum OptimizeFor

        {

            Unspecified,

            Speed,

            Accuracy

} 

        public sealed class Options

        {

            [Option('r', "read", MetaValue = "FILE", Required = true, HelpText = "Input file with data to process.")]

            public string InputFile {get; set;}

​

            [Option('w', "write", MetaValue = "FILE", HelpText = "Output FILE with processed data (otherwise standard output).")]

            public string OutputFile { get; set; }

​

            [Option("calculate", HelpText = "Add results in bottom of tabular data.")]

            public bool Calculate { get; set; }

​

            [Option('v', MetaValue = "INT", HelpText = "Verbose level. Range: from 0 to 2.")]

            public int? VerboseLevel { get; set; }

             //Long name should be longer than one character.]

            [Option('i', HelpText = "If file has errors don't stop processing.")]

            public bool IgnoreErrors { get; set; }

​

            //@@@ replace Def

           // [Option('j', "jump", MetaValue = "INT", DefaultValue = 0, HelpText = "Data processing start offset.")]

             [Option('j', "jump", MetaValue = "INT", Default = 0, HelpText = "Data processing start offset.")]

            public double StartOffset { get; set; }

​

            [Option("optimize", HelpText = "Optimize for Speed|Accuracy.")]

            public OptimizeFor Optimization {get;set;}

​

            //@@@ comment temorary

//            [ValueList(typeof(List<string>))]

 //           public IList<string> DefinitionFiles { get; set; }

            [Value(0)]

            public IEnumerable<string> DefinitionFiles { get; set; }

//@@@ Convert 

          //  [OptionList('o', "operators", Separator = ';', HelpText = "Operators included in processing (+;-;...)." +

        //        " Separate each operator with a semicolon." + " Do not include spaces between operators and separator.")]

         //   public IList<string> AllowedOperators { get; set; }

​

               [Option('o', "operators", Separator = ';', HelpText = "Operators included in processing (+;-;...)." +

                " Separate each operator with a semicolon." + " Do not include spaces between operators and separator.")]

             public IEnumerable<string> AllowedOperators { get; set; }

            //

            // Marking a property of type IParserState with ParserStateAttribute allows you to

            // receive an instance of ParserState (that contains a IList<ParsingError>).

            // This is equivalent from inheriting from CommandLineOptionsBase (of previous versions)

            // with the advantage to not propagating a type of the library.

            //

//@@ comment    ParserState  obsolete   

     //       [ParserState]

     //       public IParserState LastParserState { get; set; }

​

//@@ comment 

        //    [HelpOption]

         //   public string GetUsage()

         //   {

         //       return HelpText.AutoBuild(this, current => HelpText.DefaultParsingErrorsHandler(this, current));

         //   }

}

​

​

​

​

​

​

​