Beispiel #1
0
        public object[] BuildParameterArray(MethodInfo method)
        {
            int argumentIndex   = _metadata.IsMulticommand ? 1 : 0;
            var parameterValues = new List <object>();
            var aliases         = new Dictionary <string, Consolery.ParameterData>();

            foreach (ParameterInfo info in method.GetParameters())
            {
                if (_metadata.IsRequired(info))
                {
                    parameterValues.Add(StringToObject.ConvertValue(_args[argumentIndex], info.ParameterType));
                }
                else
                {
                    var optional = _metadata.GetOptional(info);

                    foreach (string altName in optional.AltNames)
                    {
                        aliases.Add(altName.ToLower(),
                                    new Consolery.ParameterData(parameterValues.Count, info.ParameterType));
                    }
                    aliases.Add(info.Name.ToLower(),
                                new Consolery.ParameterData(parameterValues.Count, info.ParameterType));
                    parameterValues.Add(optional.Default);
                }
                argumentIndex++;
            }
            foreach (string optionalParameter in OptionalParameters(method))
            {
                string name  = ParameterName(optionalParameter);
                string value = ParameterValue(optionalParameter);
                parameterValues[aliases[name].Position] = StringToObject.ConvertValue(value, aliases[name].Type);
            }
            return(parameterValues.ToArray());
        }
Beispiel #2
0
        public object[] BuildParameterArray(MethodInfo method)
        {
            var optionalValues = new Dictionary <string, string>();

            for (var i = 0; i < _args.Length - _metadata.RequiredParameterCount(method); i += 2)
            {
                optionalValues.Add(_args[i].Substring(1), _args[i + 1]);
            }
            var parameters      = method.GetParameters();
            var parameterValues = parameters.Select(p => (object)null).ToList();

            var requiredStartIndex = _args.Length - _metadata.RequiredParameterCount(method);
            var requiredValues     = _args.Where((a, i) => i >= requiredStartIndex).ToList();

            for (var i = 0; i < requiredValues.Count; i++)
            {
                parameterValues[i] = StringToObject.ConvertValue(requiredValues[i], parameters[i].ParameterType);
            }
            for (var i = _metadata.RequiredParameterCount(method); i < parameters.Length; i++)
            {
                var optional = _metadata.GetOptional(parameters[i]);
                if (optionalValues.ContainsKey(parameters[i].Name))
                {
                    parameterValues[i] = StringToObject.ConvertValue(optionalValues[parameters[i].Name], parameters[i].ParameterType);
                }
                else
                {
                    parameterValues[i] = optional.Default;
                }
            }
            return(parameterValues.ToArray());
        }
Beispiel #3
0
 private void CheckOptionalParametersDefaultValuesAreAssignableToRealParameterTypes(MethodBase method)
 {
     foreach (ParameterInfo parameter in method.GetParameters())
     {
         if (_metadata.IsRequired(parameter))
         {
             continue;
         }
         var optional = _metadata.GetOptional(parameter);
         if (optional.Default != null && optional.Default.GetType() == typeof(string) &&
             StringToObject.CanBeConvertedToDate(optional.Default.ToString()))
         {
             return;
         }
         if ((optional.Default == null && !parameter.ParameterType.CanBeNull()) ||
             (optional.Default != null && !optional.Default.GetType().IsAssignableFrom(parameter.ParameterType)))
         {
             throw new NConsolerException(
                       "Default value for an optional parameter \"{0}\" in method \"{1}\" can not be assigned to the parameter",
                       parameter.Name, method.Name);
         }
     }
 }