コード例 #1
0
ファイル: Program.cs プロジェクト: pattersonwr/Host
        static bool ValidateParameters(MethodDetails md, int argumentCount)
        {
            int requiredCount = md.MethodParameters.Where(p => p.IsOptional == false).Count();
            int optionalCount = md.MethodParameters.Where(p => p.IsOptional == true).Count();
            int providedCount = argumentCount;

            if (requiredCount > providedCount)
            {
                Console.WriteLine("Failed to provide the correct number of required arguments.");
                Console.WriteLine("You provided {0} arguments, there are {1} required arguments, and {2} optional arguments." + Environment.NewLine,
                                  providedCount, requiredCount, optionalCount);

                // Display Help Text for the Method
                md.DisplayHelpText();

                return(false);
            }
            else if (providedCount > requiredCount)
            {
                Console.WriteLine("Provided too many arguments. When using a string make sure to wrap it in quotes if it has spaces so it will be treated as a single argument");
                Console.WriteLine("You provided {0} arguments, there are {1} required arguments, and {2} optional arguments." + Environment.NewLine,
                                  providedCount, requiredCount, optionalCount);

                // Display Help Text for the Method
                md.DisplayHelpText();

                return(false);
            }

            return(true);
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: pattersonwr/Host
 static void InvokeMethod(MethodDetails method, object[] paramArray)
 {
     try
     {
         method.Method.Invoke(_this, paramArray);
     }
     catch (TargetInvocationException ex)
     {
         throw ex.InnerException;
     }
 }
コード例 #3
0
ファイル: Program.cs プロジェクト: pattersonwr/Host
        static void ExecuteCommand(HostCommand cmd)
        {
            try
            {
                // Validate The Passed in Command
                if (!ValidateCommand(cmd))
                {
                    Console.WriteLine("{0} is an invalid command", cmd.MethodName);
                    Help();
                    return;
                }

                // Make sure the user provided the correct number of arguments
                MethodDetails methodDetails = _methodDictionary[cmd.MethodName];

                if (!ValidateParameters(methodDetails, cmd.Arguments.Count()))
                {
                    return;
                }

                object[] inputs = GetMethodParams(methodDetails, cmd.Arguments);

                InvokeMethod(methodDetails, inputs);
            }
            catch (Exception e)
            {
                Console.WriteLine();
                WriteExceptions(e);

                if (e.InnerException != null)
                {
                    Console.WriteLine();
                    WriteExceptions(e.InnerException);
                }
            }
        }
コード例 #4
0
ファイル: Program.cs プロジェクト: pattersonwr/Host
        static object[] GetMethodParams(MethodDetails method, IEnumerable <string> args)
        {
            var methodParams = new List <object>();

            if (method.MethodParameters.Count() > 0)
            {
                foreach (var param in method.MethodParameters)
                {
                    methodParams.Add(param.DefaultValue);
                }

                if (args.Count() == 0)
                {
                    return(methodParams.ToArray());
                }

                if (method.MethodParameters.HasParameterType <List <string> >())
                {
                    List <string> arguments = new List <string>();

                    for (int i = 0; i < args.Count(); ++i)
                    {
                        var arg = args.ElementAt(i);

                        if (args.ElementAt(i).Contains(","))
                        {
                            var s = arg.Replace(",", "");

                            if (s != string.Empty)
                            {
                                arguments.Add(s);
                            }
                        }
                        else
                        {
                            arguments.Add(arg);
                        }
                    }

                    args = new List <string>()
                    {
                        string.Join(",", arguments.ToArray())
                    };
                }

                for (int i = 0; i < args.Count(); ++i)
                {
                    var methodParam  = method.MethodParameters.ElementAt(i);
                    var requiredType = methodParam.ParameterType;

                    object value = null;

                    try
                    {
                        MethodInfo changeTypeMethod = null;

                        if (!requiredType.IsGenericType)
                        {
                            changeTypeMethod = typeof(HostExtensions).GetMethod("ChangeType");
                        }
                        else
                        {
                            changeTypeMethod = typeof(HostExtensions).GetMethod("ChangeTypeList");
                        }

                        var genericMethod = changeTypeMethod.MakeGenericMethod(requiredType);

                        value = genericMethod.Invoke(null, new object[] { args.ElementAt(i), CultureInfo.CurrentCulture });

                        methodParams[i] = value;
                    }
                    catch (Exception ex)
                    {
                        throw new ArgumentException(string.Format("The value for '{0}' cannot be parsed to '{1}' ", methodParam.Name, requiredType.Name), ex);
                    }
                }
            }

            return(methodParams.ToArray());
        }