public static CommandValueLookup GetParameterValues(CommandTree?tree, ITypeResolver resolver)
        {
            var lookup = new CommandValueLookup();
            var binder = new CommandValueBinder(lookup);

            CommandValidator.ValidateRequiredParameters(tree);

            while (tree != null)
            {
                // Process unmapped parameters.
                foreach (var parameter in tree.Unmapped)
                {
                    if (parameter.IsFlagValue())
                    {
                        // Set the flag value to an empty, not set instance.
                        var instance = Activator.CreateInstance(parameter.ParameterType);
                        lookup.SetValue(parameter, instance);
                    }
                    else
                    {
                        // Is this an option with a default value?
                        if (parameter.DefaultValue != null)
                        {
                            var value = parameter.DefaultValue?.Value;

                            // Need to convert the default value?
                            if (value != null && value.GetType() != parameter.ParameterType)
                            {
                                var converter = GetConverter(lookup, binder, resolver, parameter);
                                if (converter != null)
                                {
                                    value = converter.ConvertFrom(value);
                                }
                            }

                            binder.Bind(parameter, resolver, value);
                            CommandValidator.ValidateParameter(parameter, lookup);
                        }
                        else if (Nullable.GetUnderlyingType(parameter.ParameterType) != null ||
                                 !parameter.ParameterType.IsValueType)
                        {
                            lookup.SetValue(parameter, null);
                        }
                    }
                }

                // Process mapped parameters.
                foreach (var mapped in tree.Mapped)
                {
                    if (mapped.Parameter.WantRawValue)
                    {
                        // Just try to assign the raw value.
                        binder.Bind(mapped.Parameter, resolver, mapped.Value);
                    }
                    else
                    {
                        var converter = GetConverter(lookup, binder, resolver, mapped.Parameter);
                        if (converter == null)
                        {
                            throw CommandRuntimeException.NoConverterFound(mapped.Parameter);
                        }

                        if (mapped.Parameter.IsFlagValue() && mapped.Value == null)
                        {
                            if (mapped.Parameter is CommandOption option && option.DefaultValue != null)
                            {
                                // Set the default value.
                                binder.Bind(mapped.Parameter, resolver, option.DefaultValue?.Value);
                            }
                            else
                            {
                                // Set the flag but not the value.
                                binder.Bind(mapped.Parameter, resolver, null);
                            }
                        }
Exemplo n.º 2
0
        public static CommandValueLookup GetParameterValues(CommandTree?tree, ITypeResolver resolver)
        {
            var lookup = new CommandValueLookup();
            var binder = new CommandValueBinder(lookup);

            CommandValidator.ValidateRequiredParameters(tree);

            while (tree != null)
            {
                // Process unmapped parameters.
                foreach (var parameter in tree.Unmapped)
                {
                    // Got a value provider?
                    if (parameter.ValueProvider != null)
                    {
                        var context = new CommandParameterContext(parameter, resolver, null);
                        if (parameter.ValueProvider.TryGetValue(context, out var result))
                        {
                            result = ConvertValue(resolver, lookup, binder, parameter, result);

                            lookup.SetValue(parameter, result);
                            CommandValidator.ValidateParameter(parameter, lookup, resolver);
                            continue;
                        }
                    }

                    if (parameter.IsFlagValue())
                    {
                        // Set the flag value to an empty, not set instance.
                        var instance = Activator.CreateInstance(parameter.ParameterType);
                        lookup.SetValue(parameter, instance);
                    }
                    else
                    {
                        // Is this an option with a default value?
                        if (parameter.DefaultValue != null)
                        {
                            var value = parameter.DefaultValue?.Value;
                            value = ConvertValue(resolver, lookup, binder, parameter, value);

                            binder.Bind(parameter, resolver, value);
                            CommandValidator.ValidateParameter(parameter, lookup, resolver);
                        }
                        else if (Nullable.GetUnderlyingType(parameter.ParameterType) != null ||
                                 !parameter.ParameterType.IsValueType)
                        {
                            lookup.SetValue(parameter, null);
                        }
                    }
                }

                // Process mapped parameters.
                foreach (var mapped in tree.Mapped)
                {
                    if (mapped.Parameter.WantRawValue)
                    {
                        // Just try to assign the raw value.
                        binder.Bind(mapped.Parameter, resolver, mapped.Value);
                    }
                    else
                    {
                        if (mapped.Parameter.IsFlagValue() && mapped.Value == null)
                        {
                            if (mapped.Parameter is CommandOption option && option.DefaultValue != null)
                            {
                                // Set the default value.
                                binder.Bind(mapped.Parameter, resolver, option.DefaultValue?.Value);
                            }
                            else
                            {
                                // Set the flag but not the value.
                                binder.Bind(mapped.Parameter, resolver, null);
                            }
                        }