C# ICommandManager.RegisterCommand方法代码示例

        public RibbonViewModel(IRegexService regexService, ICommandManager commandManager, 
            INavigationService navigationService, IConfigurationService configurationService, IUIVisualizerService uiVisualizerService,
            IWorkspaceManager workspaceManager, IPleaseWaitService pleaseWaitService, IFilterService filterService)
        {
            Argument.IsNotNull(() => regexService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => configurationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => workspaceManager);
            Argument.IsNotNull(() => pleaseWaitService);
            Argument.IsNotNull(() => filterService);

            _regexService = regexService;
            Filter = filterService.Filter;
            _navigationService = navigationService;
            _configurationService = configurationService;
            _uiVisualizerService = uiVisualizerService;
            _workspaceManager = workspaceManager;
            _pleaseWaitService = pleaseWaitService;
            _filterService = filterService;

            SaveWorkspace = new Command(OnSaveWorkspaceExecute, OnSaveWorkspaceCanExecute);
            CreateWorkspace = new Command(OnCreateWorkspaceExecute);

            ShowSettings = new Command(OnShowSettingsExecute);
            ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);

            Exit = new Command(OnExitExecute);

            commandManager.RegisterCommand(Commands.Settings.General, ShowSettings, this);
            commandManager.RegisterCommand(Commands.File.Exit, Exit, this);

            Title = AssemblyHelper.GetEntryAssembly().Title();
        }

        public RibbonViewModel(INavigationService navigationService, IUIVisualizerService uiVisualizerService,
            ICommandManager commandManager, IRecentlyUsedItemsService recentlyUsedItemsService, IProcessService processService,
            IMessageService messageService, ISelectDirectoryService selectDirectoryService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => selectDirectoryService);

            _navigationService = navigationService;
            _uiVisualizerService = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _processService = processService;
            _messageService = messageService;
            _selectDirectoryService = selectDirectoryService;

            OpenProject = new Command(OnOpenProjectExecute);
            OpenRecentlyUsedItem = new Command<string>(OnOpenRecentlyUsedItemExecute);
            OpenInExplorer = new Command<string>(OnOpenInExplorerExecute);
            UnpinItem = new Command<string>(OnUnpinItemExecute);
            PinItem = new Command<string>(OnPinItemExecute);

            ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);

            commandManager.RegisterCommand("File.Open", OpenProject, this);

            var assembly = AssemblyHelper.GetEntryAssembly();
            Title = assembly.Title();
        }

            public CCommand(ICommandManager commandManager, ulong id)
            {
                m_comamndManager = commandManager;
                m_id = id;
                m_bIsViewCommand = false;

                m_comamndManager.RegisterCommand(this);
            }

        public RibbonViewModel(INavigationService navigationService, 
            IUIVisualizerService uiVisualizerService,
            ICommandManager commandManager, 
            IRecentlyUsedItemsService recentlyUsedItemsService, 
            IOpenFileService openFileService,
            IMessageService messageService,
            IProcessService processService,
            IFileService fileService)
        {
            Argument.IsNotNull(() => navigationService);
            Argument.IsNotNull(() => uiVisualizerService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => processService);
            Argument.IsNotNull(() => fileService);

            _navigationService = navigationService;
            _uiVisualizerService = uiVisualizerService;
            _recentlyUsedItemsService = recentlyUsedItemsService;
            _openFileService = openFileService;
            _messageService = messageService;
            _processService = processService;
            _fileService = fileService;

            Help = new Command(OnHelpExecute);
            Open = new Command(this.OnOpenExecute);
            Exit = new Command(OnExitExecute);
            ShowKeyboardMappings = new Command(OnShowKeyboardMappingsExecute);

            OpenRecentlyUsedItem = new Command<string>(OnOpenRecentlyUsedItemExecute);
            UnpinItem = new Command<string>(OnUnpinItemExecute);
            PinItem = new Command<string>(OnPinItemExecute);
            OpenInExplorer = new Command<string>(OnOpenInExplorerExecute);

            OnRecentlyUsedItemsServiceUpdated(null, null);

            commandManager.RegisterCommand("Help.About", Help, this);
            commandManager.RegisterCommand("File.Open", Open, this);
            commandManager.RegisterCommand("File.Exit", Exit, this);
        }

        public LogEntriesViewModel(ICommandManager commandManager, IUIServiceHost uiServiceHost)
        {
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => uiServiceHost);

            _uiServiceHost = uiServiceHost;

            LogEntries = new ObservableCollection<LogEntry>();

            ClearLog = new Command(OnClearLogExecute);

            commandManager.RegisterCommand("Log.Clear", ClearLog, this);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewModel" /> class.
        /// </summary>
        public MainViewModel(IUIServiceHost uiServiceHost, IMessageService messageService,
            ISelectDirectoryService selectDirectoryService, ICommandManager commandManager, ISettings settings)
        {
            Argument.IsNotNull(() => uiServiceHost);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => selectDirectoryService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => settings);

            _uiServiceHost = uiServiceHost;
            _messageService = messageService;
            _selectDirectoryService = selectDirectoryService;
            Settings = settings;

            BenchmarkResults = new ObservableCollection<BenchmarkResult>();

            CloseBenchmarkResult = new Command<BenchmarkResult>(OnCloseBenchmarkResultExecute);
            SwitchTimeAxis = new Command(OnSwitchTimeAxisExecute);
            SaveAllResults = new Command(OnSaveAllResultsExecute);
            ChangeDefaultAxis = new Command(OnChangeDefaultAxisExecute);

            commandManager.RegisterCommand("File.SaveAllResults", SaveAllResults, this);
            commandManager.RegisterCommand("Options.ChangeDefaultAxis", ChangeDefaultAxis, this);
        }

        public ShellViewModel(ITaskRunnerService taskRunnerService, ICommandManager commandManager)
        {
            Argument.IsNotNull(() => taskRunnerService);
            Argument.IsNotNull(() => commandManager);

            _taskRunnerService = taskRunnerService;
            _commandManager = commandManager;

            Run = new Command(OnRunExecute, OnRunCanExecute);

            _commandManager.RegisterCommand("Runner.Run", Run, this);

            SuspendValidation = true;

            Title = taskRunnerService.Title;
        }

        public ShellViewModel(ITaskRunnerService taskRunnerService, ICommandManager commandManager)
        {
            Argument.IsNotNull(() => taskRunnerService);
            Argument.IsNotNull(() => commandManager);

            _taskRunnerService = taskRunnerService;

            Run = new TaskCommand(OnRunExecuteAsync, OnRunCanExecute);

            commandManager.RegisterCommand("Runner.Run", Run, this);

            SuspendValidation = true;

            Title = taskRunnerService.Title;
            taskRunnerService.TitleChanged += (sender, args) => Title = taskRunnerService.Title;
        }

        public LogRecordsTableViewModel(IFilterService filterService, ICommandManager commandManager, IFileBrowserService fileBrowserService,
            ILogTableService logTableService)
        {
            Argument.IsNotNull(() => filterService);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => fileBrowserService);
            Argument.IsNotNull(() => logTableService);

            _filterService = filterService;
            _logTableService = logTableService;
            FileBrowser = fileBrowserService.FileBrowserModel;
            Filter = filterService.Filter;
            LogTable = logTableService.LogTable;

            ResetSearchTemplate = new Command(OnResetSearchTemplateExecute);

            commandManager.RegisterCommand(Commands.Filter.ResetSearchTemplate, ResetSearchTemplate, this);
        }

        public TypesViewModel(IOpenFileService openFileService, IPleaseWaitService pleaseWaitService,
            IUIServiceHost uiServiceHost, IReflectionService reflectionService, ICommandManager commandManager)
        {
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => pleaseWaitService);
            Argument.IsNotNull(() => uiServiceHost);
            Argument.IsNotNull(() => reflectionService);
            Argument.IsNotNull(() => commandManager);

            _openFileService = openFileService;
            _pleaseWaitService = pleaseWaitService;
            _uiServiceHost = uiServiceHost;
            _reflectionService = reflectionService;

            Assemblies = new List<AssemblyEntry>();

            FileOpen = new Command(OnFileOpenExecute);
            ClearFilter = new Command(OnClearFilterExecute);

            commandManager.RegisterCommand("File.Open", FileOpen, this);
        }

        public void OnPluginLoaded(ICommandManager CommandManager,IMinecraftHandler mc)
        {
            this.mc = mc;
            CommandManager.RegisterCommand("lotto", new CommandLotto(mc));
            CommandManager.RegisterCommand("jackpot", new CommandJackpot(mc));
            ConfigLotto.ConfigFolder = Path.GetDirectoryName(startupPath) + Path.DirectorySeparatorChar;

            LottoUserCollection.Load().Save();
            config = ConfigLotto.Load();
            config.Save();
            users = UserCollectionSingletone.GetInstance();
            lottoEnabled = true;
            lottoThread = new Thread(new ThreadStart(LottoThread));
            lottoThread.Start();
        }

        public void OnPluginLoaded(ICommandManager CommandManager, IMinecraftHandler mc)
        {
            MinecraftHandler myMc = mc as MinecraftHandler;
            if (myMc != null)
            {

            }
            CommandManager.RegisterCommand("setcenter",new CommandSetCenter(mc));
            CommandManager.RegisterCommand("distance", new CommandDistance(mc));
            ConfigPlugin.ConfigFolder = Path.GetDirectoryName(startupPath) + Path.DirectorySeparatorChar;
            config = ConfigPlugin.Load();
            config.Save();
            this.mc = mc;
        }

        public CommandsService(StudioStateModel model,
            ICommandManager commandManager,
            IMementoService mementoService,
            IMessageService messageService,
            IOpenFileService openFileService,
            IRecentlyUsedItemsService recentlyUsedItemsService,
            ISaveFileService saveFileService,
            IProcessService processService)
        {
            Argument.IsNotNull(() => model);
            Argument.IsNotNull(() => commandManager);
            Argument.IsNotNull(() => mementoService);
            Argument.IsNotNull(() => messageService);
            Argument.IsNotNull(() => openFileService);
            Argument.IsNotNull(() => recentlyUsedItemsService);
            Argument.IsNotNull(() => saveFileService);
            Argument.IsNotNull(() => processService);

            this.model = model;
            this.commandManager = commandManager;
            this.mementoService = mementoService;
            this.messageService = messageService;
            this.openFileService = openFileService;
            this.recentlyUsedItemsService = recentlyUsedItemsService;
            this.saveFileService = saveFileService;
            this.processService = processService;

            this.UndoCommand = new Command(this.Undo, this.CanUndo);
            this.RedoCommand = new Command(this.Redo, this.CanRedo);
            this.OpenProjectCommand = new Command(this.OpenProject, () => true);

            this.SaveProjectAsCommand = new Command(delegate { this.SaveAsProject(); }, () => true);
            this.SaveProjectCommand = new Command(delegate { this.SaveProject(); }, this.CanSave);

            this.OpenRecentlyUsedItemCommand = new Command<string>(this.OnOpenRecentlyUsedItemExecute);

            this.PinItemCommand = new Command<string>(this.PinItem);
            this.UnpinItemCommand = new Command<string>(this.UnpinItem);
            this.OpenInExplorerCommand = new Command<string>(this.OpenInExplorer);

            this.StartCommand = new Command(this.Start, this.CanStart);

            this.ExitCommand = new Command(this.Exit);

            commandManager.RegisterCommand("Script.Open", this.OpenProjectCommand);
            commandManager.RegisterCommand("Script.Save", this.SaveProjectCommand);
            commandManager.RegisterCommand("Script.SaveAs", this.SaveProjectAsCommand);
            commandManager.RegisterCommand("App.Exit", this.ExitCommand);

            this.model.ProjectPropertyChanged += this.OnProjectPropertyChanged;
        }