private static IEnumerable<Match> MatchCommands(CommandParameters parameters, int argCount, CommandHandlerDescriptor descriptor, ICommandHandler handler)
 {
     foreach (var commandDescriptor in descriptor.Commands)
     {
         foreach (var name in commandDescriptor.Names)
         {
             var names = name.Split(' ');
             if (parameters.Arguments.Take(argCount).SequenceEqual(names, StringComparer.OrdinalIgnoreCase))
             {
                 yield return new Match
                 {
                     Context = new CommandContext
                     {
                         Arguments = parameters.Arguments.Skip(names.Count()),
                         Command = string.Join(" ", names),
                         CommandDescriptor = commandDescriptor,
                         Input = parameters.Input,
                         Output = parameters.Output,
                         Switches = parameters.Switches,
                     },
                     CommandHandler = handler
                 };
             }
         }
     }
 }

 public CommandController(
     ICommandHandler<CreateProductCommand> createProductCommandHandler,
     ICommandHandler<CreateProductVersionCommand> createProductVersionCommandHandler)
 {
     this.createProductCommandHandler = createProductCommandHandler;
     this.createProductVersionCommandHandler = createProductVersionCommandHandler;
 }

 public DocumentWindow(IServiceProvider serviceProvider, Microsoft.Matrix.Core.Documents.Document document)
     : base(serviceProvider)
 {
     if (document == null)
     {
         throw new ArgumentNullException("document");
     }
     this._document = document;
     try
     {
         base.SuspendLayout();
         this.InitializeUserInterface();
         this._documentView = this.CreateDocumentView();
     }
     finally
     {
         base.ResumeLayout(true);
     }
     this._documentView.DocumentChanged += new EventHandler(this.OnDocumentViewDocumentChanged);
     this._viewCommandHandler = this._documentView as ICommandHandler;
     this._viewToolboxClient = this._documentView as IToolboxClient;
     this._viewSelectionContainer = this._documentView as ISelectionContainer;
     IDesigner designer = ((IDesignerHost) serviceProvider.GetService(typeof(IDesignerHost))).GetDesigner(document);
     this._designerCommandHandler = designer as ICommandHandler;
     this._contextCommandHandler = this._document.ProjectItem.Project;
     this.UpdateCaption();
 }

        public void Register(ICommandHandler handler)
        {
            if (handler == null) throw new ArgumentNullException(nameof(handler));

            var supportedCommandTypes = handler.GetType()
                .GetInterfaces()
                .Where(iface => iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(ICommandHandler<>))
                .Select(iface => iface.GetGenericArguments()[0])
                .ToList();
            var registeredType = _handlers.Keys.FirstOrDefault(x => supportedCommandTypes.Contains(x));

            if (registeredType != null)
            {
                var commands = String.Join(", ", supportedCommandTypes.Select(x => x.FullName));
                var registeredHandler = _handlers[registeredType];
                var message = $"The command(s) ('{commands}') handled by the received handler ('{handler}') already has a registered handler ('{registeredHandler}').";

                Logging.Darjeel.TraceError(message);
                throw new ArgumentException(message);
            }

            foreach (var commandType in supportedCommandTypes)
            {
                _handlers.Add(commandType, handler);
            }
        }

 public CommandExampleController(
     ICommandHandler<CreateOrderCommand> createOrderhandler,
     ICommandHandler<ShipOrderCommand> shipOrderhandler)
 {
     this.createOrderhandler = createOrderhandler;
     this.shipOrderhandler = shipOrderhandler;
 }

 public ServiceConsumer(
     ICommandHandler<AddDelegateCommand> addHandler, 
     ICommandHandler<UpdateDelegateCommand> updateHandler)
 {
     this.addHandler = addHandler;
     this.updateHandler = updateHandler;
 }

 public OrderApiService(
     ICommandHandler<MakeOrderCommand> commmHandler,
     IOrderRepository repository)
 {
     _commmHandler = commmHandler;
     _repository = repository;
 }

        private static IEnumerable<Match> MatchCommands(CommandParameters parameters, int argCount, CommandHandlerDescriptor descriptor, ICommandHandler handler)
        {
            foreach (var commandDescriptor in descriptor.Commands)
            {
                foreach (var name in commandDescriptor.Names)
                {
                    var names = name.Split(' ');
                    // We check here number of arguments a command can recieve against
                    // arguments provided for the command to identify the correct command
                    // and avoid matching multiple commands.
                    if(commandDescriptor.MethodInfo.GetParameters().Length == argCount - names.Count())
                    {
                        names = parameters.Arguments.ToArray();
                    }

                    if (parameters.Arguments.Take(argCount).SequenceEqual(names, StringComparer.OrdinalIgnoreCase))
                    {
                        yield return new Match
                        {
                            Context = new CommandContext
                            {
                                Arguments = parameters.Arguments.Skip(name.Split(' ').Count()),
                                Command = string.Join(" ", names),
                                CommandDescriptor = commandDescriptor,
                                Input = parameters.Input,
                                Output = parameters.Output,
                                Switches = parameters.Switches,
                            },
                            CommandHandler = handler
                        };
                    }
                }
            }
        }

		public MainCommandHandlerChain(
			IConsole console,
			ICommandHandler[] commandHandlers)
		{
			_console = console;
			_commandHandlers = commandHandlers;
		}

        public ShellViewModel( ITimerHandler timerHandler, 
                               IPlaybackHandler playbackHandler, 
                               ICommandHandler commandHandler )
        {
            this.TimerHandler = timerHandler;
            this.playbackHandler = playbackHandler;

            this.TimerHandler.TimedEventCompleted += ( se, ea ) =>
            {
                this.playbackHandler.PlayTimedEventComplete( se as TimedEvent );
            };

            commandHandler.CommandRecognized += ( se, ea ) =>
            {
                this.playbackHandler.PlayCommandAccepted();

                var command = se as Command;

                if ( command.Verb == "time" )
                {
                    this.TimerHandler.Start( command.Noun );
                }
                else if ( command.Verb == "clear" )
                {
                    this.TimerHandler.Clear( command.Noun );
                }
            };
        }

 public ValidationService(IRequestResponsePairQueryService requestResponsePairQueryService,
                             IUseCaseQueryService useCaseQueryService,
                             ICommandHandler<CreateUseCaseValidation> commandHandler)
 {
     _requestResponsePairQueryService = requestResponsePairQueryService;
     _useCaseQueryService = useCaseQueryService;
     _commandHandler = commandHandler;
 }

 public UserController(ICommandHandler<CreateBasicUser> createUserCommandHandler, ICommandHandler<AddFriendToUser> addFriendCommandHandler, ICommandHandler<DisableUser> disableUserCommandHandler, ICommandHandler<AddWishListItem> addWishListItemCommandHandler, ICommandHandler<EnableUser> enableUserCommandHandler)
 {
     _createUserCommandHandler = createUserCommandHandler;
     _addFriendCommandHandler = addFriendCommandHandler;
     _disableUserCommandHandler = disableUserCommandHandler;
     _addWishListItemCommandHandler = addWishListItemCommandHandler;
     _enableUserCommandHandler = enableUserCommandHandler;
 }

 public OrganizationController(ICommandHandler<CreateOrganization, Organization> createOrganization,
     IQueryHandler<GetOrganization, Organization> getOrganization,
     IQueryHandler<ListOrganizations, IEnumerable<Organization>> listOrganizations)
 {
     _createOrganization = createOrganization;
     _getOrganization = getOrganization;
     _listOrganizations = listOrganizations;
 }

 public AccountController(ApplicationUserManager userManager,
     ApplicationSignInManager signInManager,
     ICommandHandler<RegisterUserCommand> registerUserCommandHandler)
 {
     UserManager = userManager;
     SignInManager = signInManager;
     _registerUserCommandHandler = registerUserCommandHandler;
 }

        public virtual void Invoke(ICommandHandler handler, ICommand command)
        {
            Ensure.That(handler, "handler").IsNotNull();
            Ensure.That(command, "command").IsNotNull();

            var container = ContainerFactory.Invoke(handler.ContainerType);
            handler.Handler.Invoke(container, new object[] { command });
        }

 // ----------------------------------------------------------------------
 public GenericCommand( ICommandHandler commandHandler, object context )
 {
     if ( commandHandler == null )
     {
         throw new ArgumentNullException( "commandHandler" );
     }
     this.commandHandler = commandHandler;
     this.context = context;
 }

        public CommandDispatcher(
			ICommandHandler[] handlers,
			Func<IEnumerable<ICommandHandler>> pluginHandlerFactory,
			IEventDispatcher eventDispatcher)
        {
            _handlers = handlers;
            _pluginHandlerFactory = pluginHandlerFactory;
            _eventDispatcher = eventDispatcher;
        }

        /// <summary>
        /// Registers a handler to be used to process commands.
        /// </summary>
        public void RegisterCommandHandler(ICommandHandler commandHandler)
        {
            if (commandHandler == null) throw new ArgumentNullException("commandHandler");

            if (registeredHandlers.Any(h => h.GetType() == commandHandler.GetType()))
                throw new InvalidOperationException("Handler type " + commandHandler.GetType() + " already registered.");

            registeredHandlers.Add(commandHandler);
        }

 public LoginsController
     (
         IRequestHandler<LoginRequest, string> loginHandler,
         ICommandHandler<LogoutRequest> logoutHandler
     )
 {
     this.loginHandler = loginHandler;
     this.logoutHandler = logoutHandler;
 }

        public void Construct_MultipleCommandHandlersForSameCommand_ThrowArgumentException()
        {
            // The command bus doesn't currently support multiple command handlers for the same command, make sure that it fails.
            var commandHandlers = new ICommandHandler[] {
                new TestCommandHandler(),
                new TestCommandHandler()
            };

            Assert.Throws<ArgumentException>(() => new CommandExecutor(commandHandlers));
        }