public ExecuteParams(CommandAction action, string projectName, string solutionName, string assemblyName, string projectOutput)
 {
     _action = action;
     _projectName = projectName;
     _solutionName = solutionName;
     _assemblyName = assemblyName;
     _projectOutput = projectOutput;
 }

 public CommandResponse(CommandAction botAction)
 {
     Action = botAction;
 }

        private void BuildTarget(Dictionary<string, ITask> targets, string targetName, CommandAction commandAction)
        {
            ITask task = FindTarget(targets, targetName);

            using (ITaskScope targetScope = _bounce.TaskScope(task, commandAction.Command, targetName)) {
                commandAction.Action(task);
                targetScope.TaskSucceeded();
            }
        }

		private DbCommand SetCommandInternal(CommandAction cmdAction, CommandType cmdType, string cmdText, DbParameter[] cmdParameters, bool autoPrepareCommand)
		{
			DbCommand command = this.GetCommand(cmdAction);

			command.Parameters.Clear();
			command.CommandType = cmdType;

			command.CommandText = this.PretreatmentCommandText(cmdText);

			switch (cmdAction)
			{
				case CommandAction.Select:
					_selectCommandParameters = cmdParameters;
					if (this._adapter != null)
					{
						this._adapter.Dispose();
						this._adapter = null;
					}
					if (this._builder != null)
					{
						this._builder.Dispose();
						this._builder = null;
					}
					break;
				case CommandAction.Insert:
					_insertCommandParameters = cmdParameters;
					if (this._adapter != null)
					{
						this._adapter.InsertCommand = command;
					}
					break;
				case CommandAction.Update:
					_updateCommandParameters = cmdParameters;
					if (this._adapter != null)
					{
						this._adapter.UpdateCommand = command;
					}
					break;
				case CommandAction.Delete:
					_deleteCommandParameters = cmdParameters;
					if (this._adapter != null)
					{
						this._adapter.DeleteCommand = command;
					}
					break;
				default:
					break;
			}
			if (cmdParameters != null)
			{
				for (int i = 0; i < cmdParameters.Length; i++)
				{
					command.Parameters.Add(cmdParameters[i]);
				}
			}
			if (autoPrepareCommand)
			{
				command.Prepare();
			}
			return command;
		}

 public static void RegisterCommand(CommandAction<float, float> action)
 {
     CRegistery.RegisterDelegate(action);
 }

 /// <summary>
 /// 获取命令名称。
 /// </summary>
 /// <param name="action">命令动作。</param>
 /// <param name="name">命令名称。</param>
 /// <returns>命令名称。</returns>
 public static string GetCommandName(CommandAction action, string name)
 {
     return (action == CommandAction.None ? name : string.Format("{0}-{1}", action, name)).Trim();
 }

 /// <summary>
 /// 初始化一个新的命令标记。
 /// </summary>
 /// <param name="commandAction">命令动作。</param>
 /// <param name="commandName">命令名称。</param>
 /// <param name="description">命令说明。</param>
 public CommandAttribute(CommandAction commandAction, string commandName, string description)
     : this(commandName)
 {
     Action = commandAction;
     Description = description.NotEmptyOrWhiteSpace("description");
 }

 // Queue a command to be invoked as soon as possible
 public static void QueueCommand(CommandAction command) {
     if (Instance != null) Instance.Commands.Add(command);
 }

 // Notify of a new action request
 private void Target(ActionRequest request) {
     var command = new CommandAction() {
         Entities = Selected.ToArray(),
         Request = request,
     };
     SceneManager.QueueCommand(command);
 }

 private CommandStates GetStatus(CommandAction action)
 {
     return GetCommandStatus(GetMultiStatus(), action);
 }

 public CommandLineParseException(string parserMessage, CommandAction action)
 {
     _parserMessage = parserMessage;
     _action = action;
 }

        public void RegisterCommand(string commandTag, string description, CommandAction callback)
        {
            string lowerCommand = commandTag.ToLower();
            if (commandTable.ContainsKey(lowerCommand))
            {
                throw new InvalidOperationException(
                    String.Format("Command \"{0}\" is already registered.", commandTag));
            }

            commandTable.Add(lowerCommand, new CommandInfo(commandTag, description, callback));
        }

 public CommandInfo(string commandTag, string description, CommandAction action)
 {
     this.Command = commandTag;
     this.Description = description;
     this.Callback = action;
 }

 public void AddOnce(CommandAction action)
 {
     onceMethods.Add(action);
 }

        public void Execute(CommandAction action)
        {
            if (SelectedProject == null)
                return;

            BridgeTrigger.Execute(new BridgeTrigger.ExecuteParams(action, SelectedProject.FullName, SolutionName, SelectedAssemblyName, SelectedProjectOutputPath));
        }

		private DbCommand GetCommand(CommandAction commandAction)
		{
			switch (commandAction)
			{
				case CommandAction.Insert:
					if (this._insertCommand == null)
					{
						this._insertCommand = this.CreateCommand();
					}
					return this._insertCommand;
				case CommandAction.Update:
					if (this._updateCommand == null)
					{
						this._updateCommand = this.CreateCommand();
					}
					return this._updateCommand;
				case CommandAction.Delete:
					if (this._deleteCommand == null)
					{
						this._deleteCommand = this.CreateCommand();
					}
					return this._deleteCommand;
				case CommandAction.Select:
					if (this._selectCommand == null)
					{
						this._selectCommand = this.CreateCommand();
					}
					return this._selectCommand;
				default:
					return this.CreateCommand();
			}
		}

        public void Execute(CommandAction action)
        {
            if (SelectedProject == null)
                return;

            var allProjectReferences = Crawler.FindProjectDependencies(SelectedProject.FullName, SolutionName);
            var foundProjects = allProjectReferences as IList<Dependency.Project> ?? allProjectReferences.ToList();
            var projectReferences = foundProjects.Where(project => project.DependencyType == DependencyType.ProjectReference);
            // var assemblyReferences = allProjectReferences.Where(project => project.DependencyType == DependencyType.AssemblyReference);

            var references = projectReferences as IList<Dependency.Project> ?? projectReferences.ToList();
            switch (action)
            {
                case CommandAction.Enable:
                    const string enableMessage = "Following project dependencies have been found...LINQBridge them? (Recommended)";
                    PackageConfigurator.EnableProject(SelectedProjectOutputPath, SelectedAssemblyName, SolutionName);
                    var enabledDependencies = new List<string>();
                    enabledDependencies.Insert(0, SelectedAssemblyName);

                    if (references.Any(project => PackageConfigurator.IsBridgeDisabled(project.AssemblyName, SolutionName)))
                    {
                        var projectDependencies = new ProjectDependencies(references, enableMessage);
                        var dependencies = projectDependencies.ShowDependencies(PackageConfigurator.EnableProject);
                        enabledDependencies.AddRange(dependencies.Select(project => project.AssemblyName));
                    }

                    MessageBox.Show(string.Format("LINQBridge on {0} has been Enabled...", string.Join(", ", enabledDependencies)), "Success", MessageBoxButtons.OK);

                    break;
                case CommandAction.Disable:
                    const string disableMessage = "Following project dependencies have been found...Un-LINQBridge them? (Recommended)";

                    PackageConfigurator.DisableProject(SelectedProjectOutputPath, SelectedAssemblyName, SolutionName);
                    var disableDependencies = new List<string>();
                    disableDependencies.Insert(0, SelectedAssemblyName);

                    if (references.Any(project => PackageConfigurator.IsBridgeEnabled(project.AssemblyName, SolutionName)))
                    {
                        var projectDependencies = new ProjectDependencies(references, disableMessage);
                        var dependencies = projectDependencies.ShowDependencies(PackageConfigurator.DisableProject);
                        disableDependencies.AddRange(dependencies.Select(project => project.AssemblyName));
                    }

                    MessageBox.Show(string.Format("LINQBridge on {0} has been Disabled...", string.Join(", ", disableDependencies)), "Success", MessageBoxButtons.OK);

                    break;
                default:
                    throw new ArgumentOutOfRangeException("action");
            }
        }

		private DataTableAdapter SetCommand(CommandAction cmdAction, CommandType cmdType, string cmdText, DbParameter[] cmdParameters, bool autoPrepareCommand)
		{
			this.SetCommandInternal(cmdAction, cmdType, cmdText, cmdParameters, autoPrepareCommand);

			return this;
		}

 public void UpdateCommand(MenuCommand cmd, CommandAction action)
 {
     var states = GetStatus(action);
     cmd.Visible = (CommandStates.Visible & states) != 0;
     cmd.Enabled = (CommandStates.Enabled & states) != 0;
 }

 public static Command Act(CommandAction action)
 {
     return new Command { Action = action, Time = 1 };
 }