public NimbusQueueMessageSender(IQueueManager queueManager, string queuePath)
        {
            _queueManager = queueManager;
            _queuePath = queuePath;

            _queueClient = new Lazy<MessageSender>(() => _queueManager.CreateMessageSender(_queuePath));
        }

 /// <summary>
 /// Executes the specified queue manager.
 /// </summary>
 /// <param name="queueManager">The queue manager.</param>
 /// <returns></returns>
 public CommandResult Execute(IQueueManager queueManager)
 {
     try
     {
         if (this._retrySkipCount == 0)
         {
             this._attemptCount++;
             this.InternalExecute();
             if (this._attemptCount > 1)
             {
                 queueManager.LogEvent(EventLogEntryType.Information, 0x40004405L,Environment.MachineName);
             }
             return CommandResult.Success;
         }
         this._retrySkipCount--;
         return CommandResult.Retry;
     }
     catch (Exception exception)
     {
         var sqlException = exception as SqlException;
         var asyncServiceException = exception as AsyncServiceException;
         if ((sqlException == null) && (asyncServiceException == null))
         {
             throw;
         }
         if (queueManager.ShuttingDown)
         {
             queueManager.LogEvent(EventLogEntryType.Error, 0xc0004409L, Environment.MachineName, exception.ToString() );
             return CommandResult.Failure;
         }
         return CalculateRetryOrFailure(queueManager, exception);
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MessageQueue"/> class.
        /// </summary>
        /// <param name="manager"> The queue manager for underlying queues.</param>
        /// <exception cref="System.ArgumentNullException">The manager argument can not be null.</exception>
        public MessageQueue(IQueueManager manager)
        {
            if (manager == null)
                throw new ArgumentNullException("manager");

            _manager = manager;
        }

        public NimbusTopicMessageSender(IQueueManager queueManager, string topicPath)
        {
            _queueManager = queueManager;
            _topicPath = topicPath;

            _topicClient = new Lazy<TopicClient>(() => _queueManager.CreateTopicSender(_topicPath));
        }

 public NimbusSubscriptionMessageReceiver(IQueueManager queueManager, string topicPath, string subscriptionName, ConcurrentHandlerLimitSetting concurrentHandlerLimit)
 {
     _queueManager = queueManager;
     _topicPath = topicPath;
     _subscriptionName = subscriptionName;
     _concurrentHandlerLimit = concurrentHandlerLimit;
 }

 public LightningQueuesChannel(Uri address, string queueName, IQueueManager queueManager, IDelayedMessageCache<MessageId> delayedMessages)
 {
     _address = address;
     _queueName = queueName;
     _queueManager = queueManager;
     _delayedMessages = delayedMessages;
 }

 public NimbusTopicMessageSender(IQueueManager queueManager, string topicPath, ILogger logger)
     : base()
 {
     _queueManager = queueManager;
     _topicPath = topicPath;
     _logger = logger;
 }

 public ZombusQueueMessageSender(IQueueManager queueManager, string queuePath, IZombusLogger logger)
     : base()
 {
     _queueManager = queueManager;
     _queuePath = queuePath;
     _logger = logger;
 }

 public PerformanceMonitor(IQueueManager queueManager)
 {
     _queueManager = queueManager;
     AssertCountersExist();
     AttachToEvents();
     SyncWithCurrentQueueState();
 }

 public MessagingFactory(ConcurrentHandlerLimitSetting concurrentHandlerLimit, IZombusLogger logger, PrefetchCountSetting prefetchCount, IQueueManager queueManager)
 {
     _queueManager = queueManager;
     _concurrentHandlerLimit = concurrentHandlerLimit;
     _logger = logger;
     _prefetchCount = prefetchCount;
 }

 public ErrorHeaderViewModel(
     IEventAggregator eventAggregator, 
     IContentDecoder<IList<HeaderInfo>> decoder, 
     IQueueManager queueManager) 
     : base(eventAggregator, decoder, queueManager)
 {
     DisplayName = "Errors";
 }

 public WindowsServiceBusTopicMessageSender(IBrokeredMessageFactory brokeredMessageFactory, ILogger logger, IQueueManager queueManager, IRetry retry, string topicPath)
 {
     _queueManager = queueManager;
     _retry = retry;
     _topicPath = topicPath;
     _logger = logger;
     _brokeredMessageFactory = brokeredMessageFactory;
 }

 public AzureServiceBusQueueMessageSender(IBrokeredMessageFactory brokeredMessageFactory, ILogger logger, IQueueManager queueManager, IRetry retry, string queuePath)
 {
     _brokeredMessageFactory = brokeredMessageFactory;
     _queueManager = queueManager;
     _retry = retry;
     _queuePath = queuePath;
     _logger = logger;
 }

 public OnReceiveMessageReceiver(IQueueManager queueManager, string queuePath,
     ConcurrentHandlerLimitSetting concurrentHandlerLimit, PrefetchCountSetting prefetchCount, IZombusLogger logger)
 {
     _queueManager = queueManager;
     _queuePath = queuePath;
     _concurrentHandlerLimit = concurrentHandlerLimit;
     _prefetchCount = prefetchCount;
     _logger = logger;
 }

 public QueueMessageDispatcher(ILogger logger, IQueueManager queueManager, IBrokeredMessageFactory brokeredMessageFactory,
     IEndpointNamingPolicy endpointNamingPolicy, MaxConcurrentReceiverCallsSetting maxConcurrentReceiverCallsSetting)
 {
     _logger = logger;
     _queueManager = queueManager;
     _brokeredMessageFactory = brokeredMessageFactory;
     _endpointNamingPolicy = endpointNamingPolicy;
     _maxConcurrentReceiverCallsSetting = maxConcurrentReceiverCallsSetting;
 }

 public void TestInitialize()
 {
     IList<string> machines = new List<string> { Environment.MachineName, "AnotherMachine" };
     QueueManager = Substitute.For<IQueueManager>();
     Explorer = Substitute.For<IQueueExplorerViewModel>();
     Network = Substitute.For<INetworkOperations>();
     Model = new Desktop.Shell.QueueCreationViewModel(QueueManager, Explorer, Network);
     Network.GetMachines().Returns(Task.FromResult(machines));
 }

        public MainWindowViewModel(
            IQueueManager queueManager,
            IMessageFactory factory)
        {
            this.queueManager = queueManager;
            this.messageFactory = factory;

            this.PoppedMessage = string.Empty;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MessageService"/> class.
        /// </summary>
        /// <param name="manager">The queue manager.</param>
        /// <exception cref="ArgumentNullException"><paramref name="manager"/> is <see langword="null" />.</exception>
        public MessageService(IQueueManager manager)
        {
            if (manager == null)
                throw new ArgumentNullException("manager");

            _processors = new Lazy<IList<IMessageProcessor>>(CreateProcesses);
            _manager = manager;
            _activeProcesses = 0;

        }

 public ExplorerViewModel(
     IQueueManager queueManager,
     IEventAggregator eventAggregator,
     IWindowManagerEx windowManager)
 {
     _queueManager = queueManager;
     _eventAggregator = eventAggregator;
     _windowManager = windowManager;
     Items = new BindableCollection<ExplorerItem>();
 }

	    public MusicService(ILogger logger,
			IMusicProviderFactory musicProviderFactory,
			IAutoPlay autoplayer,
            IDataService<QueuedTrack> queuedTrackDataService,
			IDataService<User> adminUserDataService,
			ISearchSuggestionService searchSuggestionService,
			IRickRollService rickRollService,
			IBroadcastService broadcastService,
			ISoundBoardService soundBoardService,
            ISkipHelper skipHelper,
            IVolume volume,
            IQueueManager queueManager,
            IAlreadyQueuedHelper alreadyQueuedHelper,
            IMusicPlayer musicPlayer,
            ICallbackClient callbackClient,
            IUserService userService,
			IVetoHelper vetoHelper,
            IQueueRuleHelper queueRuleHelper,
            ISettings settings,
            ISearchRuleHelper searchRuleHelper
            )
		{
	        this.vetoHelper = vetoHelper;
	        this.callbackClient = callbackClient;
	        this.alreadyQueuedHelper = alreadyQueuedHelper;
	        this.queueManager = queueManager;
	        this.broadcastService = broadcastService;
			this.rickRollService = rickRollService;
			this.logger = logger;
			this.musicProviderFactory = musicProviderFactory;
			this.autoplayer = autoplayer;
			this.queuedTrackDataService = queuedTrackDataService;
			this.adminUserDataService = adminUserDataService;
			this.searchSuggestionService = searchSuggestionService;
			this.soundBoardService = soundBoardService;
			this.skipHelper = skipHelper;
            this.volume = volume;
            this.musicPlayer = musicPlayer;
	        this.callbackClient = callbackClient;
            this.userService = userService;            
            this.queueRuleHelper = queueRuleHelper;
	        this.settings = settings;

	        this.searchRuleHelper = searchRuleHelper;
	        foreach (var provider in musicProviderFactory.GetAllMusicProviders())
			{
				provider.TrackEnded += musicProvider_TrackEnded;        
			}

			if (settings.AutoStart)
			{
			    PlayNextTrack();
			}
		}