public static async Task <int> Main(string[] args) { SetupConsoleEncoding(); var rootCommand = new RootCommand(); var interactiveCommand = new Command("interactive") { Handler = CommandHandler.Create <string, CancellationToken>(InteractiveCommand.Interactive) }; interactiveCommand.AddAlias("i"); var arg = new Option <string>("--project"); arg.AddAlias("-p"); interactiveCommand.Add(arg); rootCommand.Add(interactiveCommand); var studioCommand = new Command("studio") { Handler = CommandHandler.Create(StudioCommand.Studio) }; studioCommand.AddAlias("s"); rootCommand.Add(studioCommand); return(await rootCommand.InvokeAsync(args).ConfigureAwait(false)); }
static int Main(string[] args) { var rootCommand = new RootCommand("Tool to transform T4 templates during build"); var timeoutOption = new Option <int>(new string[] { "--lock-timeout", "-t" }, () => 60, "Timeout in seconds to wait for another instance to be done"); rootCommand.Add(timeoutOption); var tpArgument = new Argument <FileInfo[]>("templates", "The templates to transform").ExistingOnly(); var transformCommand = new Command("transform", "Transform the T4 templates"); transformCommand.Add(tpArgument); var skipOption = new Option <bool>(new[] { "--skip-up-to-date", "-s" }, "Skip templates whose output is up-to-date"); transformCommand.Add(skipOption); var parallelOption = new Option <bool>(new[] { "--parallel", "-p" }, "Transform templates in parallel"); transformCommand.Add(parallelOption); transformCommand.Handler = CommandHandler.Create <FileInfo[], int, bool, bool>(Transform); rootCommand.Add(transformCommand); var cleanCommand = new Command("clean", "List the output files"); cleanCommand.Add(tpArgument); cleanCommand.Handler = CommandHandler.Create <FileInfo[], int>(Clean); rootCommand.Add(cleanCommand); return(rootCommand.InvokeAsync(args).Result); }
static async Task DefineArguments(string[] args) { // <definearguments> var delayArgument = new Argument <int> (name: "delay", description: "An argument that is parsed as an int.", getDefaultValue: () => 42); var messageArgument = new Argument <string> ("message", "An argument that is parsed as a string."); var rootCommand = new RootCommand(); rootCommand.Add(delayArgument); rootCommand.Add(messageArgument); rootCommand.SetHandler((int delayArgumentValue, string messageArgumentValue) => { Console.WriteLine($"<delay> argument = {delayArgumentValue}"); Console.WriteLine($"<message> argument = {messageArgumentValue}"); }, delayArgument, messageArgument); await rootCommand.InvokeAsync(args); // </definearguments> Console.WriteLine("Sample command line."); await rootCommand.InvokeAsync("21 \"Hello world!\""); }
static async Task <int> Main(string[] args) { var command = new RootCommand(); command.Add(RunCommand(args)); command.Add(NewCommand()); command.Description = "Process manager and orchestrator for microservices."; var builder = new CommandLineBuilder(command); builder.UseHelp(); builder.UseVersionOption(); builder.UseDebugDirective(); builder.UseParseErrorReporting(); builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated); builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions builder.CancelOnProcessTermination(); builder.UseExceptionHandler(HandleException); // Allow fancy drawing. builder.UseAnsiTerminalWhenAvailable(); var parser = builder.Build(); return(await parser.InvokeAsync(args)); }
static async Task <int> Main(string[] args) { var rootCommand = new RootCommand() { }; var validateCommand = new Command("validate") { new Option("--input", "Input OpenAPI description file path or URL", typeof(string)) }; validateCommand.Handler = CommandHandler.Create <string>(OpenApiService.ValidateOpenApiDocument); var transformCommand = new Command("transform") { new Option("--input", "Input OpenAPI description file path or URL", typeof(string)), new Option("--output", "Output OpenAPI description file", typeof(FileInfo), arity: ArgumentArity.ZeroOrOne), new Option("--version", "OpenAPI specification version", typeof(OpenApiSpecVersion)), new Option("--format", "File format", typeof(OpenApiFormat)), new Option("--inline", "Inline $ref instances", typeof(bool)), new Option("--resolveExternal", "Resolve external $refs", typeof(bool)), new Option("--filterByOperationIds", "Filters OpenApiDocument by OperationId(s) provided", typeof(string)), new Option("--filterByTags", "Filters OpenApiDocument by Tag(s) provided", typeof(string)) }; transformCommand.Handler = CommandHandler.Create <string, FileInfo, OpenApiSpecVersion, OpenApiFormat, string, string, bool, bool>( OpenApiService.ProcessOpenApiDocument); rootCommand.Add(transformCommand); rootCommand.Add(validateCommand); // Parse the incoming args and invoke the handler return(await rootCommand.InvokeAsync(args)); }
static async Task DefineOptions(string[] args) { // <defineoptions> var delayOption = new Option <int> (name: "--delay", description: "An option whose argument is parsed as an int.", getDefaultValue: () => 42); var messageOption = new Option <string> ("--message", "An option whose argument is parsed as a string."); var rootCommand = new RootCommand(); rootCommand.Add(delayOption); rootCommand.Add(messageOption); rootCommand.SetHandler((int delayOptionValue, string messageOptionValue) => { Console.WriteLine($"--delay = {delayOptionValue}"); Console.WriteLine($"--message = {messageOptionValue}"); }, delayOption, messageOption); // </defineoptions> await rootCommand.InvokeAsync(args); Console.WriteLine("Sample command line."); await rootCommand.InvokeAsync("--delay 21 --message \"Hello world!\""); }
internal int Run(string[] args) { var rootCommand = new RootCommand(); rootCommand.Add(new Argument <FileInfo>("startup-assembly") { Description = "Startup assembly of the host application." }); rootCommand.Add(new Option <string>("--password", "Administrator password.")); rootCommand.Add(new Option <bool>("--no-pause", "Don't wait for user input after execution.")); //Lack of this switch means that the dbupdate command should start the command rhetos.exe dbupdate //in another process with the host applications runtimeconfig.json and deps.json files rootCommand.Add(new Option <bool>(ExecuteCommandInCurrentProcessOptionName) { IsHidden = true }); rootCommand.Handler = CommandHandler.Create((FileInfo startupAssembly, string password, bool executeCommandInCurrentProcess) => { if (executeCommandInCurrentProcess) { return(SafeExecuteCommand(() => ExecuteCommand(startupAssembly.FullName, password))); } else { return(InvokeAsExternalProcess(startupAssembly.FullName, args)); } }); return(rootCommand.Invoke(args)); }
public static int Main(string[] args) { var cmd = new RootCommand() { new Option <string>("--package-tests-sdk", "The SDK version to use for package tests"), new Option <bool>("--package-tests-suppress-nologo", "Suppress --nologo when running package tests"), new Option <bool>("--skip-pack-dependency", "Skip the \"pack\" target as a dependency"), }; cmd.Add(new Argument("targets") { Arity = ArgumentArity.ZeroOrMore, Description = "The targets to run or list." }); foreach (var option in Options.Definitions) { cmd.Add(new Option(new[] { option.ShortName, option.LongName }.Where(n => !string.IsNullOrWhiteSpace(n)).ToArray(), option.Description)); } cmd.Handler = CommandHandler.Create <string, bool, bool>((packageTestsSdk, packageTestsSuppressNoLogo, skipPackDependency) => { var cmdLine = cmd.Parse(args); var targets = cmdLine.CommandResult.Tokens.Select(token => token.Value); var options = new Options(Options.Definitions.Select(o => (o.LongName, cmdLine.ValueForOption <bool>(o.LongName)))); Run(targets, options, packageTestsSdk, packageTestsSuppressNoLogo, skipPackDependency); }); return(cmd.Invoke(args)); }
public void Run(string[] args) { _context.Database.Migrate(); Console.WriteLine("Media Processor"); Analysis analysis = new Analysis(_context, _config); Cleanup cleanup = new Cleanup(_context); Converter converter = new Converter(_context, _config); var rootCommand = new RootCommand(); var analyzeCommand = new Command("analyze"); var cmdAnalyzeFile = new Command("file"); cmdAnalyzeFile.AddOption(new Option <string>("--filename")); cmdAnalyzeFile.AddOption(new Option <string>("--content_type")); cmdAnalyzeFile.Handler = CommandHandler.Create <string, string>(analysis.ProcessFile); var cmdConvert = new Command("convert"); var cmdConvertFile = new Command("file"); cmdConvertFile.AddOption(new Option <string>("--filename")); cmdConvertFile.AddOption(new Option <string>("--content_type")); cmdConvertFile.Handler = CommandHandler.Create <string, string>(converter.ProcessFile); cmdConvert.Add(cmdConvertFile); var cmdConvertDB = new Command("db"); cmdConvertDB.Handler = CommandHandler.Create(converter.ProcessDB); cmdConvert.Add(cmdConvertDB); var cmdConvertSingleDB = new Command("singledb"); cmdConvertSingleDB.Handler = CommandHandler.Create(converter.ProcessSingleDB); cmdConvert.Add(cmdConvertSingleDB); var cmdAnalyzeDir = new Command("dir"); cmdAnalyzeDir.AddOption(new Option <string>("--path")); cmdAnalyzeDir.AddOption(new Option <string>("--content_type")); cmdAnalyzeDir.Handler = CommandHandler.Create <string, string>(analysis.ProcessDir); var cmdConfig = new Command("cfg"); var cmdConfigAnalyze = new Command("analyze"); cmdConfigAnalyze.Handler = CommandHandler.Create(analysis.AnalyzeCfg); var cmdConfigCleanup = new Command("cleanup"); cmdConfigCleanup.Handler = CommandHandler.Create(cleanup.CleanupDB); analyzeCommand.Add(cmdAnalyzeFile); analyzeCommand.Add(cmdAnalyzeDir); cmdConfig.Add(cmdConfigAnalyze); cmdConfig.Add(cmdConfigCleanup); rootCommand.Add(analyzeCommand); rootCommand.Add(cmdConfig); rootCommand.Add(cmdConvert); rootCommand.InvokeAsync(args).Wait(); }
public static void Main(string[] args) { var rootCommand = new RootCommand("Utility for inspecting the Git index file.") { new Option <string>(new[] { "-f", "--file" }) { Description = "Path to a .git/index file", } }; var infoCommand = new Command("info", "Show summary information about the index"); var listCommand = new Command("list", "List and filter index entries") { new Argument("path") { Description = "Filter based on path prefix", Arity = ArgumentArity.ZeroOrOne }, new Option <bool>("--ignore-case", "Perform case-insensitive filtering on paths"), new Option <bool>(new[] { "-U", "--ctime" }, "Use time of file creation, instead of last modification"), new Option <bool>(new[] { "-n", "--numeric-uid-gid" }, "Use numeric user and group IDs"), new Option <bool>(new[] { "-S", "--skip-worktree" }, "Show only entries with the skip-worktree bit set"), new Option <bool>(new[] { "-s", "--no-skip-worktree" }, "Do not show entries with the skip-worktree bit set") }; rootCommand.Add(infoCommand); rootCommand.Add(listCommand); infoCommand.Handler = CommandHandler.Create <InfoOptions>(Info); listCommand.Handler = CommandHandler.Create <ListOptions>(List); int exitCode = rootCommand.Invoke(args); Environment.Exit(exitCode); }
static async Task IntAndString(string[] args) { // <intandstring> var delayOption = new Option <int> ("--delay", "An option whose argument is parsed as an int."); var messageOption = new Option <string> ("--message", "An option whose argument is parsed as a string."); var rootCommand = new RootCommand("Model binding example"); rootCommand.Add(delayOption); rootCommand.Add(messageOption); rootCommand.SetHandler( // <lambda> (int delayOptionValue, string messageOptionValue) => { DisplayIntAndString(delayOptionValue, messageOptionValue); }, // </lambda> // <services> delayOption, messageOption); // </services> await rootCommand.InvokeAsync(args); // </intandstring> await rootCommand.InvokeAsync("--delay 42 --message \"Hello world!\""); }
public static Task Main(string[] args) { var collectCommand = new Command("collect") { new Option <DirectoryInfo>("--directory", getDefaultValue: () => new DirectoryInfo(Directory.GetCurrentDirectory())), new Option <string>("--pattern", getDefaultValue: () => "*.jpg"), new Option <string>("--collectionID") { Required = true }, new Option <bool>("--recurse", getDefaultValue: () => false), }; var searchCommand = new Command("search") { new Option <DirectoryInfo>("--directory", getDefaultValue: () => new DirectoryInfo(Directory.GetCurrentDirectory())), new Option <string>("--pattern", getDefaultValue: () => "*.jpg"), new Option <string>("--collectionID") { Required = true }, new Option <bool>("--recurse", getDefaultValue: () => false), }; collectCommand.Handler = CommandHandler.Create <CollectOptions>(options => new CollectCommand(options).ExecuteAsync()); searchCommand.Handler = CommandHandler.Create <SearchOptions>(options => new SearchCommand(options).ExecuteAsync()); var rootCommand = new RootCommand(); rootCommand.Add(collectCommand); rootCommand.Add(searchCommand); rootCommand.AddGlobalOption(new Option <string>("--access-key", "Amazon Rekognition access key") { Required = true }); rootCommand.AddGlobalOption(new Option <string>("--secret-key", "Amazon Rekognition secret key") { Required = true }); var regionOption = new Option <RegionEndpoint>("--region", new ParseArgument <RegionEndpoint>(target => RegionEndpoint.GetBySystemName(target.Tokens[0].Value))); regionOption.Description = "System name of an AWS region"; regionOption.Required = true; regionOption.WithSuggestions(RegionEndpoint.EnumerableAllRegions .Where(r => r.SystemName.StartsWith("eu-", StringComparison.OrdinalIgnoreCase)) .Select(r => r.SystemName) .ToArray()); rootCommand.AddGlobalOption(regionOption); rootCommand.Description = "Amazon Rekognition testing tool"; return(rootCommand.InvokeAsync(args)); }
public static int Main(string[] args) { var root = new RootCommand("Dotnet linux cert helper: Install and list PKCS#12 certificates for *nix system"); var installCommand = new Command("install", "Install certificates, optionally with password supplied") { new Option <string>(new string[] { "--path", "-f" }, "Path of the certificate") { IsRequired = true }, new Option <string>(new string[] { "--password", "-p" }, "Password of the certificate"), new Option <string>(new string[] { "--store-name", "-n" }, () => "My", "Specify store name, available value: " + "[AddressBook AuthRoot CertificateAuthority Disallowed My Root TrustedPeople TrustedPublisher]"), new Option <string>(new string[] { "--store-location", "-l" }, () => "CurrentUser", "Specify store location, available value: [CurrentUser LocalMachine]") }; var autoInstallCommand = new Command("auto-install", $"Auto install certificates (with {PKCS12_PASSWORD_EXTENSION} pairs) from path specified") { new Option <string>(new string[] { "--path", "-f" }, () => "/Certificates", "Path of the directory"), new Option <string>(new string[] { "--store-name", "-n" }, () => "My", "Specify store name, available value: " + "[AddressBook AuthRoot CertificateAuthority Disallowed My Root TrustedPeople TrustedPublisher]"), new Option <string>(new string[] { "--store-location", "-l" }, () => "CurrentUser", "Specify store location, available value: [CurrentUser LocalMachine]") }; // TODO: Remove this // For backward compatibility var autoInstallDeprecatingCommand = new Command("autoInstallCerts", $"Auto install certificates (with {PKCS12_PASSWORD_EXTENSION} pairs) from path specified") { new Option <string>(new string[] { "--path", "-f" }, () => "/Certificates", "Path of the directory") }; // Make this hidden autoInstallDeprecatingCommand.IsHidden = true; var listCommand = new Command("list", "List certificates, can be filtered by store name or location") { new Option <string>(new string[] { "--store-name", "-n" }, "Specify store name, available value: " + "[AddressBook AuthRoot CertificateAuthority Disallowed My Root TrustedPeople TrustedPublisher]"), new Option <string>(new string[] { "--store-location", "-l" }, "Specify store location, available value: [CurrentUser LocalMachine]") }; installCommand.Handler = CommandHandler.Create <string, string, string, string>(InstallCertificate); autoInstallCommand.Handler = CommandHandler.Create <string, string, string>(AutoInstallCertificates); // TODO: Remove this autoInstallDeprecatingCommand.Handler = CommandHandler.Create <string>(AutoInstallCertificates); listCommand.Handler = CommandHandler.Create <string, string>(ListCertificates); root.Add(installCommand); root.Add(autoInstallCommand); // TODO: Remove this root.Add(autoInstallDeprecatingCommand); root.Add(listCommand); return(root.InvokeAsync(args).Result); }
public static int Run(string[] args) { var rootCommand = new RootCommand(); rootCommand.Add(new Option <VerbosityLevel>("--verbosity", VerbosityLevel.Normal, "Output verbosity level. Allowed values are normal and diagnostic.")); rootCommand.Add(new Option <string[]>("--trace", Array.Empty <string>(), "Output additional trace loggers specified by name.")); var buildCommand = new Command("build", "Generates C# code, database model file and other project assets."); // CurrentDirectory by default, because rhetos.exe on *build* is expected to be located in NuGet package cache. buildCommand.Add(new Argument <DirectoryInfo>("project-root-folder", () => new DirectoryInfo(Environment.CurrentDirectory)) { Description = "Project folder where csproj file is located. If not specified, current working directory is used by default." }); buildCommand.Add(new Option <bool>("--msbuild-format", false, "Adjust error output format for MSBuild integration.")); buildCommand.Handler = CommandHandler.Create((DirectoryInfo projectRootFolder, bool msbuildFormat, VerbosityLevel verbosity, string[] trace) => { var program = new Program(verbosity, trace); program.SafeExecuteCommand(() => program.Build(projectRootFolder.FullName), "Build", msbuildFormat); }); rootCommand.AddCommand(buildCommand); var dbUpdateCommand = new Command("dbupdate", "Updates the database structure and initializes the application data in the database."); dbUpdateCommand.Add(new Argument <FileInfo>("startup-assembly") { Description = "Startup assembly of the host application." }); dbUpdateCommand.Add(new Option <bool>("--short-transactions", "Commit transaction after creating or dropping each database object.")); dbUpdateCommand.Add(new Option <bool>("--skip-recompute", "Skip automatic update of computed data with KeepSynchronized. See output log for data that needs updating.")); //Lack of this switch means that the dbupdate command should start the command rhetos.exe dbupdate //in another process with the host applications runtimeconfig.json and deps.json files var executeCommandInCurrentProcessOption = new Option <bool>(ExecuteCommandInCurrentProcessOptionName); executeCommandInCurrentProcessOption.IsHidden = true; dbUpdateCommand.Add(executeCommandInCurrentProcessOption); dbUpdateCommand.Handler = CommandHandler.Create((FileInfo startupAssembly, bool shortTransactions, bool skipRecompute, bool executeCommandInCurrentProcess, VerbosityLevel verbosity, string[] trace) => { var program = new Program(verbosity, trace); if (executeCommandInCurrentProcess) { return(program.SafeExecuteCommand(() => program.DbUpdate(startupAssembly.FullName, shortTransactions, skipRecompute), "DbUpdate", msBuildErrorFormat: false)); } else { return(program.InvokeDbUpdateAsExternalProcess(startupAssembly.FullName, args)); } }); rootCommand.AddCommand(dbUpdateCommand); return(rootCommand.Invoke(args)); }
private Task WrapAsync(string[] args) { var rootCommand = new RootCommand(); //这里会调用下面的方法 var addCommand = Utils.CreateAddCommand(ConvertOptionsAndDoNextAsync <AddOptions>); var deleteCommand = Utils.CreateDeleteCommand(ConvertOptionsAndDoNextAsync <DeleteOptions>); var lookupCommand = Utils.CreateSearchCommand(ConvertOptionsAndDoNextAsync <LookOptions>); rootCommand.Add(addCommand); rootCommand.Add(deleteCommand); rootCommand.Add(lookupCommand); return(rootCommand.InvokeAsync(args)); }
private static CommandLineBuilder BuildCommandLine() { RootCommand root = new RootCommand("parent") { Description = "Microsoft IoT Plug and Play Device Model Repository CLI" }; root.Add(BuildExportCommand()); root.Add(BuildValidateCommand()); root.Add(BuildImportModelCommand()); return(new CommandLineBuilder(root)); }
private static CommandLineBuilder GetCommandLine() { RootCommand root = new RootCommand("parent") { Description = $"Microsoft IoT Models Repository CommandLine v{Outputs.CommandLineVersion}" }; root.Name = Outputs.RootCommandName; root.Add(BuildExportCommand()); root.Add(BuildValidateCommand()); root.Add(BuildImportModelCommand()); root.Add(BuildRepoIndexCommand()); root.Add(BuildRepoExpandCommand()); root.AddGlobalOption(CommonOptions.Debug); root.AddGlobalOption(CommonOptions.Silent); CommandLineBuilder builder = new CommandLineBuilder(root); builder.UseMiddleware(async(context, next) => { AzureEventSourceListener listener = null; try { if (context.ParseResult.Tokens.Any(x => x.Type == TokenType.Option && x.Value == "--debug")) { Outputs.WriteHeader(); listener = AzureEventSourceListener.CreateConsoleLogger(EventLevel.Verbose); Outputs.WriteDebug(context.ParseResult.ToString()); } if (context.ParseResult.Tokens.Any(x => x.Type == TokenType.Option && x.Value == "--silent")) { System.Console.SetOut(TextWriter.Null); } await next(context); } finally { if (listener != null) { listener.Dispose(); } } }); return(builder); }
private static RootCommand BuildRootCommand() { var rootCommand = new RootCommand(); rootCommand.Handler = CommandHandler.Create((IHelpBuilder help) => { help.Write(rootCommand); }); rootCommand.Add(BuildExtractCommand()); rootCommand.Add(BuildQueueCommand()); rootCommand.Add(BuildQueueAllCommand()); return(rootCommand); }
public static async Task <int> Main(string[] args) { var command = new RootCommand(); command.Add(ScrapeCommand.Create()); command.Description = "Scrapes test results from AzDO, xUnit files, etc. and stores it in a database."; var builder = new CommandLineBuilder(command); builder.UseHelp(); builder.UseVersionOption(); builder.UseDebugDirective(); builder.UseParseErrorReporting(); builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated); builder.UsePrefixes(new[] { "-", "--", }); // disable garbage windows conventions builder.CancelOnProcessTermination(); builder.UseExceptionHandler(HandleException); // Allow fancy drawing. builder.UseAnsiTerminalWhenAvailable(); var parser = builder.Build(); return(await parser.InvokeAsync(args)); }
public CodeFenceAnnotationsParser( IDefaultCodeBlockAnnotations defaultAnnotations = null, Action <Command> configureCsharpCommand = null, Action <Command> configureFsharpCommand = null, Action <Command> configureConsoleCommand = null) { _defaultAnnotations = defaultAnnotations; var languageBinder = new Lazy <ModelBinder>(() => new ModelBinder(CodeBlockAnnotationsType)); _modelBindersByCommand = new Dictionary <ICommand, Lazy <ModelBinder> > { [CreateCsharpCommand(configureCsharpCommand)] = languageBinder, [CreateFsharpCommand(configureFsharpCommand)] = languageBinder, [CreateConsoleCommand(configureConsoleCommand)] = new Lazy <ModelBinder>(() => new ModelBinder(typeof(OutputBlockAnnotations))) }; _supportedLanguages = new HashSet <string>(_modelBindersByCommand.Keys.SelectMany(c => c.Aliases)); var rootCommand = new RootCommand(); foreach (var command in _modelBindersByCommand.Keys) { rootCommand.Add((Command)command); } _parser = new Parser(rootCommand); }
public async Task <int> Run(string[] args) { var root = new RootCommand(); root.Add(_serviceProvider.GetRequiredService <TestVerb>()); return(await root.InvokeAsync(args)); }
public static RootCommand GetRootCommand() { var rootCommand = new RootCommand(); rootCommand.Name = "nrustlightning-cli"; rootCommand.Description = "CLI interface for requesting to NRustLightning server"; foreach (var op in GetOptions()) { rootCommand.Add(op); } foreach (var sub in GetSubCommands()) { rootCommand.AddCommand(sub); } rootCommand.AddValidator(result => { var hasNetwork = result.Children.Contains("network"); if (result.Children.Contains("mainnet") && hasNetwork) { return("You cannot specify both '--network' and '--mainnet'"); } if (result.Children.Contains("testnet") && hasNetwork) { return("You cannot specify both '--network' and '--testnet'"); } if (result.Children.Contains("regtest") && hasNetwork) { return("You cannot specify both '--network' and '--regtest'"); } return(null); }); return(rootCommand); }
static async Task FromAmong(string[] args) { // <staticlist> var languageOption = new Option <string>( "--language", "An option that that must be one of the values of a static list.") .FromAmong( "csharp", "fsharp", "vb", "pwsh", "sql"); // </staticlist> var rootCommand = new RootCommand("Static list example"); rootCommand.Add(languageOption); rootCommand.SetHandler((string languageOptionValue) => { Console.WriteLine($"--language = {languageOptionValue}"); }, languageOption); await rootCommand.InvokeAsync(args); Console.WriteLine("Request help, provide a valid language, provide an invalid language."); await rootCommand.InvokeAsync("-h"); await rootCommand.InvokeAsync("--language csharp"); await rootCommand.InvokeAsync("--language not-a-language"); }
static int Main(string[] args) { RootCommand root = new RootCommand(); Command addUser = new Command("adduser") { new Option <string>(new string[] { "--username", "-u" }, description: "The name of the user/account"), new Option <string>(new string[] { "--password", "-p" }, description: "The password for the new user/account"), }; addUser.Handler = CommandHandler.Create <string, string>(async(username, password) => { IConfiguration config = new ConfigurationBuilder() .AddJsonFile("appsettings.json", true, true) .AddJsonFile("secrets.json", true, true) .Build(); CalorieContext db = new CalorieContext(config); AuthService auth = new AuthService(db); await auth.CreateUserAsync(username, password); Console.WriteLine("User {0} created", username); }); root.Add(addUser); return(root.InvokeAsync(args).Result); }
static async Task FileInfoExample(string[] args) { // <fileinfo> var fileOption = new Option <FileInfo>("--file"); var command = new RootCommand(); command.Add(fileOption); command.SetHandler( (FileInfo? file) => { if (file is not null) { Console.WriteLine($"File name: {file?.FullName}"); } else { Console.WriteLine("Not a valid file name."); } }, fileOption); await command.InvokeAsync(args); // </fileinfo> await command.InvokeAsync("--file scl.runtimeconfig.json"); await command.InvokeAsync("--file newfile.json"); }
static async Task ArraysAndLists(string[] args) { // <ienumerable> var itemsOption = new Option <IEnumerable <string> >("--items") { AllowMultipleArgumentsPerToken = true }; var command = new RootCommand("IEnumerable binding example"); command.Add(itemsOption); command.SetHandler( (IEnumerable <string> items) => { Console.WriteLine(items.GetType()); foreach (var item in items) { Console.WriteLine(item); } }, itemsOption); await command.InvokeAsync(args); // </ienumerable> await command.InvokeAsync("--items one --items two --items three"); await command.InvokeAsync("--items one two three"); }
static async Task HiddenOption(string[] args) { // <hiddenoption> var endpointOption = new Option <Uri>("--endpoint") { IsHidden = true }; var command = new RootCommand(); command.Add(endpointOption); command.SetHandler( (Uri? uri) => { Console.WriteLine(uri?.GetType()); Console.WriteLine(uri?.ToString()); }, endpointOption); await command.InvokeAsync(args); // </hiddenoption> Console.WriteLine("Request help for hidden option."); await command.InvokeAsync("-h"); Console.WriteLine("Provide hidden option."); await command.InvokeAsync("--endpoint https://contoso.com"); }
private Parser GetDirectiveParser() { if (_directiveParser == null) { var root = new RootCommand(); foreach (var c in _directiveCommands) { root.Add(c); } var commandLineBuilder = new CommandLineBuilder(root) .ParseResponseFileAs(ResponseFileHandling.Disabled) .UseMiddleware( context => context.BindingContext .AddService( typeof(KernelInvocationContext), () => KernelInvocationContext.Current)); commandLineBuilder.EnableDirectives = false; _directiveParser = commandLineBuilder.Build(); } return(_directiveParser); }
public JetfireRootCommand(IEnumerable <IJetfireSubCommand> subCommands) { Command = new RootCommand { new Option <string>( alias: "--cluster", description: "The CDF cluster where Jetfire is hosted (e.g. greenfield, europe-west1-1)" ) }; foreach (var subCommand in subCommands) { Command.Add(subCommand.Command); } var _ = new CommandLineBuilder(Command) .UseVersionOption() .UseHelp() .UseParseDirective() .UseDebugDirective() .UseSuggestDirective() .RegisterWithDotnetSuggest() .UseTypoCorrections() .UseParseErrorReporting() .CancelOnProcessTermination() .Build(); }
public static RootCommand AppendFactoriesCommand( this RootCommand baseCommand, IEnumerable <EntityFactory> factories ) { factories.ToList().ForEach(f => baseCommand.Add(f.GenerateCommand())); return(baseCommand); }