Пример #1
0
        public async Task ExecuteAsync(CliActionContext context)
        {
            if (context.ActionRoute?.ControllerType == null || context.ActionRoute?.ActionMethod == null)
            {
                throw new NoActionException();
            }

            await ExecuteActionRouteAsync(context);
        }
Пример #2
0
        public async Task <int> ExecuteAsync(string[] args)
        {
            if (_middlewarePipeline == null)
            {
                throw new InvalidOperationException("CLI action runtime not initialized");
            }

            var context = new CliActionContext(new CliActionRequest(args));

            await _middlewarePipeline(context);

            return(context.ReturnCode);
        }
Пример #3
0
        private static object[] CreateActionArguments(CliActionContext context)
        {
            var parameters = context.ActionRoute !.ActionMethod.GetParameters();

            switch (parameters.Length)
            {
            case 0:
                return(Array.Empty <object>());

            case > 1:
                throw new TargetParameterCountException("Action argument count must be 0 or 1");

            default:
            {
                var option = new OptionParser(parameters.First().ParameterType).Parse(context.Arguments.ToArray());

                return(new[] { option });
            }
            }
        }
Пример #4
0
        private async Task ExecuteActionRouteAsync(CliActionContext context)
        {
            var controller = context.ActionRoute !.ControllerType.CreateInstance <object>(_serviceProvider);

            var actionArguments = CreateActionArguments(context);

            var result = context.ActionRoute.ActionMethod.Invoke(controller, actionArguments);

            var isVoid = context.ActionRoute.ActionMethod.ReturnType == typeof(void);

            if (result == null && !isVoid)
            {
                throw new ActionReturnValueNullException();
            }

            if (isVoid)
            {
                return;
            }

            var resultType = result !.GetType();

            if (resultType == typeof(Task <CliActionResult>))
            {
                var actionResult = await(Task <CliActionResult>) result;

                context.ReturnCode = actionResult.ReturnCode;

                return;
            }

            if (resultType == typeof(Task <int>))
            {
                var returnCode = await(Task <int>) result;

                context.ReturnCode = returnCode;

                return;
            }

            if (result is Task taskResult)
            {
                await taskResult;

                return;
            }

            if (resultType == typeof(int))
            {
                context.ReturnCode = (int)result;

                return;
            }

            if (resultType != typeof(CliActionResult))
            {
                throw new ActionReturnTypeNotSupportedException(resultType);
            }

            context.ReturnCode = ((CliActionResult)result).ReturnCode;
        }