Пример #1
0
        private static void AppendVerbHelpText(StringBuilder sb, VerbAttribute attrib, char argPrefix, PropertyInfo[] verbProperties)
        {
            string cmd = attrib.Name;

            if (verbProperties.Length > 0)
            {
                cmd += " [options]";
            }

            sb.AppendFormat("  {0,-25}{1}", cmd, attrib.Description);
            sb.AppendLine();

            foreach (PropertyInfo param in verbProperties)
            {
                var paramAttrib = param.GetCustomAttributes(typeof(NamedArgumentExAttribute), false)
                                  .FirstOrDefault() as NamedArgumentExAttribute;

                if (paramAttrib != null)
                {
                    AppendArgHelpText(sb, argPrefix, paramAttrib);
                }
            }

            sb.AppendLine();
        }
Пример #2
0
 private static List <string> Create(VerbAttribute verb)
 {
     return(new List <string>()
     {
         verb.Name
     });
 }
        public void IsNameSetCorrectly()
        {
            const string name = "name";
            var          verb = new VerbAttribute(name);

            Assert.AreEqual(name, verb.Name);
        }
Пример #4
0
 public static Verb FromAttribute(VerbAttribute attribute)
 {
     return new Verb(
         attribute.Name,
         attribute.HelpText
         );
 }
Пример #5
0
 public static Verb FromAttribute(VerbAttribute attribute)
 {
     return(new Verb(
                attribute.Name,
                attribute.HelpText
                ));
 }
Пример #6
0
        private static Command CreateCommand(Type type, VerbAttribute verbAttribute)
        {
            ImmutableArray <CommandArgument> .Builder arguments = ImmutableArray.CreateBuilder <CommandArgument>();
            ImmutableArray <CommandOption> .Builder   options   = ImmutableArray.CreateBuilder <CommandOption>();

            Dictionary <string, string> providerMap = type
                                                      .GetCustomAttributes <OptionValueProviderAttribute>()
                                                      .ToDictionary(f => f.PropertyName, f => f.ProviderName);

            foreach (PropertyInfo propertyInfo in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                OptionAttribute optionAttribute = null;

                foreach (Attribute attribute in propertyInfo.GetCustomAttributes())
                {
                    if (attribute is ValueAttribute valueAttribute)
                    {
                        var argument = new CommandArgument(
                            index: valueAttribute.Index,
                            name: valueAttribute.MetaName,
                            description: valueAttribute.HelpText,
                            isRequired: valueAttribute.Required);

                        arguments.Add(argument);
                        break;
                    }
                    else if (optionAttribute == null)
                    {
                        optionAttribute = attribute as OptionAttribute;

                        if (optionAttribute != null)
                        {
                            continue;
                        }
                    }
                }

                if (optionAttribute != null)
                {
                    Debug.Assert(propertyInfo.PropertyType != typeof(bool) || string.IsNullOrEmpty(optionAttribute.MetaValue), $"{type.Name}.{propertyInfo.Name}");

                    var option = new CommandOption(
                        name: optionAttribute.LongName,
                        shortName: optionAttribute.ShortName,
                        metaValue: optionAttribute.MetaValue,
                        description: optionAttribute.HelpText,
                        isRequired: optionAttribute.Required,
                        valueProviderName: (providerMap.TryGetValue(propertyInfo.Name, out string valueProviderName)) ? valueProviderName : null);

                    options.Add(option);
                }
            }

            return(new Command(
                       verbAttribute.Name,
                       verbAttribute.HelpText,
                       arguments.OrderBy(f => f.Index),
                       options.OrderBy(f => f.Name, StringComparer.InvariantCulture)));
        }
Пример #7
0
        private Verb GetVerbFrom(IVerbOptions parsed)
        {
            VerbAttribute verbAttribute = parsed.GetType().GetCustomAttribute <VerbAttribute>();
            string        verbName      = verbAttribute.Name;
            Verb          verb          = VerbHelper.FromName(verbName);

            return(verb);
        }
Пример #8
0
 public static Verb FromAttribute(VerbAttribute attribute)
 {
     return(new Verb(
                attribute.Name,
                attribute.HelpText,
                attribute.Alias,
                attribute.Hidden
                ));
 }
Пример #9
0
        /// <summary>
        /// Creates a <see cref="Verb"/> from a <see cref="VerbAttribute"/>.
        /// </summary>
        /// <param name="attribute">The attribute to create the verb from.</param>
        /// <exception cref="ArgumentNullException"></exception>
        /// <returns>The created <see cref="Verb"/> instance.</returns>
        public static Verb FromAttribute(VerbAttribute attribute)
        {
            if (attribute == null)
            {
                throw new ArgumentNullException(nameof(attribute));
            }

            return(new Verb(attribute.Name, attribute.HelpText));
        }
Пример #10
0
        public void IsHelpTextSetCorrectly()
        {
            const string helpText = "SomeHelp";
            var          verb     = new VerbAttribute("name")
            {
                HelpText = helpText
            };

            Assert.AreEqual(helpText, verb.HelpText);
        }
Пример #11
0
        private void TestHelpWrittenForVerbs(StringBuilder helpBuilder, params Type[] verbsInHelp)
        {
            string[] helpLines = helpBuilder.ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);

            int helpIndex = 4;

            foreach (Type verbType in verbsInHelp)
            {
                VerbAttribute verbAttribute = (VerbAttribute)verbType.GetCustomAttributes(typeof(VerbAttribute), false)[0];
                NormalizeHelpLine(helpLines[helpIndex]).Should().Be(NormalizeHelpLine($"{verbAttribute.Name}{verbAttribute.HelpText}"));
                helpIndex++;
            }
        }
Пример #12
0
        public static IEnumerable <Command> LoadCommands(Assembly assembly)
        {
            foreach (System.Reflection.TypeInfo type in assembly.GetTypes())
            {
                if (!type.IsAbstract)
                {
                    VerbAttribute verbAttribute = type.GetCustomAttribute <VerbAttribute>();

                    if (verbAttribute != null)
                    {
                        yield return(CreateCommand(type, verbAttribute));
                    }
                }
            }
        }
Пример #13
0
        private void AppendVerbHelpText(StringBuilder sb, VerbAttribute attrib, char argPrefix, PropertyInfo[] verbProperties)
        {
            var namedArgAttributes = new List <NamedArgumentAttribute>();
            var cmd = new StringBuilder(attrib.Name);

            foreach (PropertyInfo param in verbProperties)
            {
                var positionalArg = GetAttribute <PositionalArgumentAttribute>(param);
                var namedArg      = GetAttribute <NamedArgumentAttribute>(param);

                if (positionalArg?.MetaVar != null)
                {
                    cmd.AppendFormat(" <{0}>", positionalArg.MetaVar);
                }

                if (namedArg != null)
                {
                    namedArgAttributes.Add(namedArg);
                }
            }

            if (namedArgAttributes.Count > 0)
            {
                cmd.Append(" [options]");
            }

            sb.Append("  ");
            sb.AppendFormat($"{{0,{-DescriptionDistance}}}", cmd.ToString());

            if (cmd.Length >= DescriptionDistance)
            {
                sb.AppendLine();
                sb.Append("  ");
                sb.AppendFormat($"{{0,{-DescriptionDistance}}}", "");
            }

            sb.Append(attrib.Description);
            sb.AppendLine();

            foreach (NamedArgumentAttribute arg in namedArgAttributes)
            {
                AppendArgHelpText(sb, argPrefix, arg);
            }

            sb.AppendLine();
        }
Пример #14
0
        private void AppendVerbHelpText(StringBuilder sb, VerbAttribute attrib, char argPrefix, PropertyInfo[] verbProperties)
        {
            string cmd = attrib.Name;

            foreach (PropertyInfo param in verbProperties)
            {
                var paramAttrib = GetAttribute <PositionalArgumentAttribute>(param);

                if (paramAttrib?.MetaVar != null)
                {
                    cmd += $" <{paramAttrib.MetaVar}>";
                }
            }

            if (verbProperties.Length > 0)
            {
                cmd += " [options]";
            }

            sb.Append("  ");
            sb.AppendFormat($"{{0,{-DescriptionDistance}}}", cmd);

            if (cmd.Length >= DescriptionDistance)
            {
                sb.AppendLine();
                sb.Append("  ");
                sb.AppendFormat($"{{0,{-DescriptionDistance}}}", "");
            }

            sb.Append(attrib.Description);
            sb.AppendLine();

            foreach (PropertyInfo param in verbProperties)
            {
                var paramAttrib = GetAttribute <NamedArgumentAttribute>(param);

                if (paramAttrib != null)
                {
                    AppendArgHelpText(sb, argPrefix, paramAttrib);
                }
            }

            sb.AppendLine();
        }
Пример #15
0
        public static Command LoadCommand(Assembly assembly, string commandName)
        {
            foreach (System.Reflection.TypeInfo type in assembly.GetTypes())
            {
                if (type.IsAbstract)
                {
                    continue;
                }

                VerbAttribute verbAttribute = type.GetCustomAttribute <VerbAttribute>();

                if (verbAttribute?.Name == commandName)
                {
                    return(CreateCommand(type, verbAttribute));
                }
            }

            return(null);
        }
Пример #16
0
        internal VerbNode(Type verb)
        {
            Type        = verb;
            Attr        = VerbAttribute.FromType(verb);
            OptionNodes = new List <OptionNode>();

            // Add member option fields
            foreach (FieldInfo info in verb.GetFields())
            {
                if (info.GetCustomAttributes(true).Any(attr => attr is OptionAttribute))
                {
                    OptionNodes.Add(new FieldOptionNode(info));
                }
            }

            // Add member option properties
            foreach (PropertyInfo info in verb.GetProperties())
            {
                if (info.GetCustomAttributes(true).Any(attr => attr is OptionAttribute))
                {
                    OptionNodes.Add(new PropertyOptionNode(info));
                }
            }
        }
Пример #17
0
        private static int Main(string[] args)
        {
            //WriteLine($"Orang Command Line Tool version {typeof(Program).GetTypeInfo().Assembly.GetName().Version}");
            //WriteLine("Copyright (c) Josef Pihrt. All rights reserved.");
            //WriteLine();

            if (args != null)
            {
                if (args.Length == 1)
                {
                    if (IsHelpOption(args[0]))
                    {
                        Console.Write(HelpProvider.GetHelpText());
                        return(0);
                    }
                }
                else if (args.Length == 2)
                {
                    if (args?.Length == 2 &&
                        IsHelpOption(args[1]))
                    {
                        Command command = CommandLoader.LoadCommand(typeof(HelpCommand).Assembly, args[0]);

                        if (command != null)
                        {
                            Console.Write(HelpProvider.GetHelpText(command));
                            return(0);
                        }
                    }
                }
            }

            try
            {
                ParserSettings defaultSettings = Parser.Default.Settings;

                var parser = new Parser(settings =>
                {
                    settings.AutoHelp    = false;
                    settings.AutoVersion = defaultSettings.AutoVersion;
                    settings.CaseInsensitiveEnumValues = defaultSettings.CaseInsensitiveEnumValues;
                    settings.CaseSensitive             = defaultSettings.CaseSensitive;
                    settings.EnableDashDash            = true;
                    settings.HelpWriter             = null;
                    settings.IgnoreUnknownArguments = defaultSettings.IgnoreUnknownArguments;
                    settings.MaximumDisplayWidth    = defaultSettings.MaximumDisplayWidth;
                    settings.ParsingCulture         = defaultSettings.ParsingCulture;
                });

                ParserResult <object> parserResult = parser.ParseArguments <
                    CopyCommandLineOptions,
                    DeleteCommandLineOptions,
                    EscapeCommandLineOptions,
                    FindCommandLineOptions,
                    HelpCommandLineOptions,
                    ListSyntaxCommandLineOptions,
                    MatchCommandLineOptions,
                    MoveCommandLineOptions,
                    RenameCommandLineOptions,
                    ReplaceCommandLineOptions,
                    SplitCommandLineOptions
                    >(args);

                bool help    = false;
                bool success = true;

                parserResult.WithNotParsed(_ =>
                {
                    var helpText = new HelpText(SentenceBuilder.Create(), HelpProvider.GetHeadingText());

                    helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText);

                    VerbAttribute verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>();

                    if (verbAttribute != null)
                    {
                        helpText.AddPreOptionsText(Environment.NewLine + HelpProvider.GetFooterText(verbAttribute.Name));
                    }

                    Console.Error.WriteLine(helpText);

                    success = false;
                });

                parserResult.WithParsed <AbstractCommandLineOptions>(options =>
                {
                    if (options.Help)
                    {
                        string commandName = options.GetType().GetCustomAttribute <VerbAttribute>().Name;

                        Console.WriteLine(HelpProvider.GetHelpText(commandName));

                        help = true;
                        return;
                    }

                    success = false;

                    var defaultVerbosity = Verbosity.Normal;

                    if (options.Verbosity == null ||
                        TryParseVerbosity(options.Verbosity, out defaultVerbosity))
                    {
                        ConsoleOut.Verbosity = defaultVerbosity;

                        if (TryParseOutputOptions(options.Output, OptionNames.Output, out string filePath, out Verbosity fileVerbosity, out Encoding encoding, out bool append))
                        {
                            if (filePath != null)
                            {
                                FileMode fileMode = (append)
                                    ? FileMode.Append
                                    : FileMode.Create;

                                var stream = new FileStream(filePath, fileMode, FileAccess.Write, FileShare.Read);
                                var writer = new StreamWriter(stream, encoding, bufferSize: 4096, leaveOpen: false);
                                Out        = new TextWriterWithVerbosity(writer)
                                {
                                    Verbosity = fileVerbosity
                                };
                            }

                            success = true;
                        }
                        else
                        {
                            success = false;
                        }
                    }
                });

                if (help)
                {
                    return(0);
                }

                if (!success)
                {
                    return(2);
                }

                return(parserResult.MapResult(
                           (CopyCommandLineOptions options) => Copy(options),
                           (MoveCommandLineOptions options) => Move(options),
                           (DeleteCommandLineOptions options) => Delete(options),
                           (EscapeCommandLineOptions options) => Escape(options),
                           (FindCommandLineOptions options) => Find(options),
                           (HelpCommandLineOptions options) => Help(options),
                           (ListSyntaxCommandLineOptions options) => ListSyntax(options),
                           (MatchCommandLineOptions options) => Match(options),
                           (RenameCommandLineOptions options) => Rename(options),
                           (ReplaceCommandLineOptions options) => Replace(options),
                           (SplitCommandLineOptions options) => Split(options),
                           _ => 2));
            }
Пример #18
0
 private static OptionKind GetValueKind22(OptionAttribute option, ValueAttribute value, VerbAttribute verb)
 {
     if (verb != null)
     {
         return(OptionKind.Verb);
     }
     if (option != null)
     {
         return(option.Separator == '\0' ? OptionKind.Single : OptionKind.List);
     }
     if (value != null)
     {
         return(OptionKind.Single);
     }
     return(OptionKind.Unknown);
 }
Пример #19
0
        public static string GetClassVerb <T>()
        {
            VerbAttribute verbAttr = typeof(T).GetCustomAttribute <VerbAttribute>();

            return(verbAttr.Name);
        }
Пример #20
0
        private static int Main(string[] args)
        {
#if DEBUG
            if (args.LastOrDefault() == "--debug")
            {
                WriteArgs(args.Take(args.Length - 1).ToArray(), Verbosity.Quiet);
                return(ExitCodes.NotSuccess);
            }
#endif
            Parser parser = null;
            try
            {
                parser = CreateParser(ignoreUnknownArguments: true);

                if (args == null ||
                    args.Length == 0)
                {
                    HelpCommand.WriteCommandsHelp();
                    return(ExitCodes.Success);
                }

                bool?success = null;

                ParserResult <BaseCommandLineOptions> defaultResult = parser
                                                                      .ParseArguments <BaseCommandLineOptions>(args)
                                                                      .WithParsed(options =>
                {
                    if (!options.Help)
                    {
                        return;
                    }

                    string commandName = args?.FirstOrDefault();
                    Command command    = (commandName != null)
                            ? CommandLoader.LoadCommand(typeof(Program).Assembly, commandName)
                            : null;

                    if (!ParseVerbosityAndOutput(options))
                    {
                        success = false;
                        return;
                    }

                    WriteArgs(args, Verbosity.Diagnostic);

                    if (command != null)
                    {
                        HelpCommand.WriteCommandHelp(command);
                    }
                    else
                    {
                        HelpCommand.WriteCommandsHelp();
                    }

                    success = true;
                });

                if (success == false)
                {
                    return(ExitCodes.Error);
                }

                if (success == true)
                {
                    return(ExitCodes.Success);
                }

                parser = CreateParser();

                ParserResult <object> parserResult = parser.ParseArguments(
                    args,
                    new Type[]
                {
                    typeof(AnalyzeCommandLineOptions),
                    typeof(FixCommandLineOptions),
                    typeof(FormatCommandLineOptions),
                    typeof(GenerateDocCommandLineOptions),
                    typeof(GenerateDocRootCommandLineOptions),
                    typeof(HelpCommandLineOptions),
                    typeof(ListSymbolsCommandLineOptions),
                    typeof(LogicalLinesOfCodeCommandLineOptions),
                    typeof(MigrateCommandLineOptions),
                    typeof(PhysicalLinesOfCodeCommandLineOptions),
                    typeof(RenameSymbolCommandLineOptions),
                    typeof(SpellcheckCommandLineOptions),
#if DEBUG
                    typeof(AnalyzeAssemblyCommandLineOptions),
                    typeof(FindSymbolsCommandLineOptions),
                    typeof(GenerateSourceReferencesCommandLineOptions),
                    typeof(ListVisualStudioCommandLineOptions),
                    typeof(ListReferencesCommandLineOptions),
                    typeof(SlnListCommandLineOptions),
#endif
                });

                parserResult.WithNotParsed(e =>
                {
                    if (e.Any(f => f.Tag == ErrorType.VersionRequestedError))
                    {
                        Console.WriteLine(typeof(Program).GetTypeInfo().Assembly.GetName().Version);
                        success = false;
                        return;
                    }

                    var helpText = new HelpText(SentenceBuilder.Create(), HelpCommand.GetHeadingText());

                    helpText = HelpText.DefaultParsingErrorsHandler(parserResult, helpText);

                    VerbAttribute verbAttribute = parserResult.TypeInfo.Current.GetCustomAttribute <VerbAttribute>();

                    if (verbAttribute != null)
                    {
                        helpText.AddPreOptionsText(Environment.NewLine + HelpCommand.GetFooterText(verbAttribute.Name));
                    }

                    Console.Error.WriteLine(helpText);

                    success = false;
                });

                if (success == true)
                {
                    return(ExitCodes.Success);
                }

                if (success == false)
                {
                    return(ExitCodes.Error);
                }

                parserResult.WithParsed <AbstractCommandLineOptions>(
                    options =>
                {
                    if (ParseVerbosityAndOutput(options))
                    {
                        WriteArgs(args, Verbosity.Diagnostic);
                    }
                    else
                    {
                        success = false;
                    }
                });

                if (success == false)
                {
                    return(ExitCodes.Error);
                }

                return(parserResult.MapResult(
                           (MSBuildCommandLineOptions options) =>
                {
                    switch (options)
                    {
                    case AnalyzeCommandLineOptions analyzeCommandLineOptions:
                        return AnalyzeAsync(analyzeCommandLineOptions).Result;

                    case FixCommandLineOptions fixCommandLineOptions:
                        return FixAsync(fixCommandLineOptions).Result;

                    case FormatCommandLineOptions formatCommandLineOptions:
                        return FormatAsync(formatCommandLineOptions).Result;

                    case GenerateDocCommandLineOptions generateDocCommandLineOptions:
                        return GenerateDocAsync(generateDocCommandLineOptions).Result;

                    case GenerateDocRootCommandLineOptions generateDocRootCommandLineOptions:
                        return GenerateDocRootAsync(generateDocRootCommandLineOptions).Result;

                    case ListSymbolsCommandLineOptions listSymbolsCommandLineOptions:
                        return ListSymbolsAsync(listSymbolsCommandLineOptions).Result;

                    case LogicalLinesOfCodeCommandLineOptions logicalLinesOfCodeCommandLineOptions:
                        return LogicalLinesOrCodeAsync(logicalLinesOfCodeCommandLineOptions).Result;

                    case PhysicalLinesOfCodeCommandLineOptions physicalLinesOfCodeCommandLineOptions:
                        return PhysicalLinesOfCodeAsync(physicalLinesOfCodeCommandLineOptions).Result;

                    case RenameSymbolCommandLineOptions renameSymbolCommandLineOptions:
                        return RenameSymbolAsync(renameSymbolCommandLineOptions).Result;

                    case SpellcheckCommandLineOptions spellcheckCommandLineOptions:
                        return SpellcheckAsync(spellcheckCommandLineOptions).Result;

#if DEBUG
                    case FindSymbolsCommandLineOptions findSymbolsCommandLineOptions:
                        return FindSymbolsAsync(findSymbolsCommandLineOptions).Result;

                    case GenerateSourceReferencesCommandLineOptions generateSourceReferencesCommandLineOptions:
                        return GenerateSourceReferencesAsync(generateSourceReferencesCommandLineOptions).Result;

                    case ListReferencesCommandLineOptions listReferencesCommandLineOptions:
                        return ListReferencesAsync(listReferencesCommandLineOptions).Result;

                    case SlnListCommandLineOptions slnListCommandLineOptions:
                        return SlnListAsync(slnListCommandLineOptions).Result;
#endif
                    default:
                        throw new InvalidOperationException();
                    }
                },
                           (AbstractCommandLineOptions options) =>
                {
                    switch (options)
                    {
                    case HelpCommandLineOptions helpCommandLineOptions:
                        return Help(helpCommandLineOptions);

                    case MigrateCommandLineOptions migrateCommandLineOptions:
                        return Migrate(migrateCommandLineOptions);

#if DEBUG
                    case AnalyzeAssemblyCommandLineOptions analyzeAssemblyCommandLineOptions:
                        return AnalyzeAssembly(analyzeAssemblyCommandLineOptions);

                    case ListVisualStudioCommandLineOptions listVisualStudioCommandLineOptions:
                        return ListVisualStudio(listVisualStudioCommandLineOptions);
#endif
                    default:
                        throw new InvalidOperationException();
                    }
                },
                           _ => ExitCodes.Error));
            }
            catch (Exception ex) when(ex is AggregateException ||
                                      ex is FileNotFoundException ||
                                      ex is InvalidOperationException)
            {
                WriteError(ex);
            }
            finally
            {
                parser?.Dispose();
                Out?.Dispose();
                Out = null;
            }

            return(ExitCodes.Error);
        }
Пример #21
0
        private static async Task <int> Main(string[] args)
        {
            VirtualTerminal.Enable();

            int        exitCode = 0;
            DevAccount account  = ToolAuthentication.LoadLastSignedInUser();

            if (account == null)
            {
                Console.Error.WriteLine("Didn't find dev signin info, please use \"XblDevAccount.exe signin\" to initiate.");
                return(-1);
            }

            if (account.AccountSource != DevAccountSource.WindowsDevCenter)
            {
                Console.Error.WriteLine("You must sign in with a valid Windows Dev Center account.");
            }

            string invokedVerb = null;
            object opts        = null;

            Console.WriteLine($"Using Dev account {account.Name} from {account.AccountSource}");
            try
            {
                // Find all of the subclasses which inherit from BaseOptions.
                Type[] argumentTypes = typeof(Program).GetNestedTypes(BindingFlags.NonPublic).Where(c => c.IsSubclassOf(typeof(BaseOptions))).ToArray();

                // Only assign the option and verb here, as the commandlineParser doesn't support async callback yet.
                Parser.Default.ParseArguments(args, argumentTypes)
                .WithParsed(options =>
                {
                    VerbAttribute verbAttribute = Attribute.GetCustomAttribute(options.GetType(), typeof(VerbAttribute)) as VerbAttribute;
                    invokedVerb = verbAttribute?.Name;
                    opts        = options;
                })
                .WithNotParsed(err => exitCode = -1);

                if (opts != null)
                {
                    // Find property called AccountId. If it not set, then set it to the logged in user's account Id.
                    PropertyInfo accountIdProperty = opts.GetType().GetProperty("AccountId");
                    if (accountIdProperty != null)
                    {
                        Guid accountIdPropertyValue = (Guid)accountIdProperty.GetValue(opts);
                        if (accountIdPropertyValue == Guid.Empty)
                        {
                            accountIdProperty.SetValue(opts, new Guid(account.AccountId));
                        }
                    }

                    // Find the method which takes this class as an argument.
                    MethodInfo method = typeof(Program).GetMethods(BindingFlags.Static | BindingFlags.NonPublic).Where(c => c.GetParameters().FirstOrDefault()?.ParameterType == opts.GetType()).FirstOrDefault();
                    if (method == null)
                    {
                        // This should never happen, but just in case...
                        throw new InvalidOperationException($"Method with parameter {opts.GetType()} not found.");
                    }

                    Task <int> methodResult = (Task <int>)method.Invoke(null, new object[] { opts });
                    exitCode = await methodResult;
                }
            }
            catch (HttpRequestException ex)
            {
                Console.Error.WriteLine($"Error: XblConfig {invokedVerb} failed.");

                if (ex.Message.Contains(Convert.ToString((int)HttpStatusCode.Unauthorized)))
                {
                    Console.Error.WriteLine(
                        $"Unable to authorize the account with the XboxLive service, please contact your administrator.");
                }
                else if (ex.Message.Contains(Convert.ToString((int)HttpStatusCode.Forbidden)))
                {
                    Console.Error.WriteLine(
                        "Your account doesn't have access to perform the operation, please contact your administrator.");
                }
                else
                {
                    Console.WriteLine(ex.Message);
                }

                exitCode = -1;
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine("Error: unexpected error found.");
                Console.Error.WriteLine(ex.Message);
                exitCode = -1;
            }

            if (System.Diagnostics.Debugger.IsAttached)
            {
                Console.Read();
            }

            return(exitCode);
        }