public Mailer(IEmailGenerator emailGenerator, IQueue<MailMessage> queue, FormattingPluginManager pluginManager, IMetricsClient metrics, ILogger<Mailer> logger) {
     _emailGenerator = emailGenerator;
     _queue = queue;
     _pluginManager = pluginManager;
     _metrics = metrics;
     _logger = logger;
 }

 public MessagePublisher(IAdvancedBus bus, ILogger logger, IExchange exchange, IQueue queue)
 {
     _bus = bus;
     _logger = logger;
     _exchange = exchange;
     _queue = queue;
 }

 public void Bind(IQueue destination, IExchange source, params string[] topics)
 {
     foreach (var topic in topics)
     {
         _model.QueueBind(destination.Name, source.Name, topic);
     }
 }

 internal LuceneSearchDeps(SearcherManager searcherManager, QueryParser parser, IMetaDataResolver resolver, IQueue queue)
 {
     this.SearcherManager = searcherManager;
     this.Parser = parser;
     this.Resolver = resolver;
     this.Queue = queue;
 }

  public ExclusiveConsumer(
      IQueue queue,
      Func<byte[], MessageProperties, MessageReceivedInfo, Task> onMessage,
      IPersistentConnection connection,
      IConsumerConfiguration configuration,
      IInternalConsumerFactory internalConsumerFactory,
      IEventBus eventBus
      )
  {
      Preconditions.CheckNotNull(queue, "queue");
      Preconditions.CheckNotNull(onMessage, "onMessage");
      Preconditions.CheckNotNull(connection, "connection");
      Preconditions.CheckNotNull(internalConsumerFactory, "internalConsumerFactory");
      Preconditions.CheckNotNull(eventBus, "eventBus");
      Preconditions.CheckNotNull(configuration, "configuration");
 
      this.queue = queue;
      this.onMessage = onMessage;
      this.connection = connection;
      this.configuration = configuration;
      this.internalConsumerFactory = internalConsumerFactory;
      this.eventBus = eventBus;
      timer = new Timer(s =>
          {
              StartConsumer();
              ((Timer)s).Change(10000, -1);
          });
      timer.Change(10000, -1);
  }

 public QueueNotificationAction(IQueue<EventNotificationWorkItem> notificationQueue, IQueue<WebHookNotification> webHookNotificationQueue, IWebHookRepository webHookRepository, WebHookDataPluginManager webHookDataPluginManager, ILoggerFactory loggerFactory = null) : base(loggerFactory) {
     _notificationQueue = notificationQueue;
     _webHookNotificationQueue = webHookNotificationQueue;
     _webHookRepository = webHookRepository;
     _webHookDataPluginManager = webHookDataPluginManager;
     ContinueOnError = true;
 }

 public SystemHealthChecker(ICacheClient cacheClient, IElasticClient elasticClient, IFileStorage storage, IQueue<StatusMessage> queue, IMessageBus messageBus) {
     _cacheClient = cacheClient;
     _elasticClient = elasticClient;
     _storage = storage;
     _queue = queue;
     _messageBus = messageBus;
 }

 public QueueMessageProcessor(ISleepService sleepService, IQueue queue, ITraceService traceService, IQueueMessageParser messageParser)
 {
     _sleepService = sleepService;
     _queue = queue;
     _traceService = traceService;
     _messageParser = messageParser;
 }

 public AdminController(IFileStorage fileStorage, IMessagePublisher messagePublisher, IOrganizationRepository organizationRepository, IQueue<EventPost> eventPostQueue, IQueue<WorkItemData> workItemQueue) {
     _fileStorage = fileStorage;
     _messagePublisher = messagePublisher;
     _organizationRepository = organizationRepository;
     _eventPostQueue = eventPostQueue;
     _workItemQueue = workItemQueue;
 }

        protected override IQueue<SimpleWorkItem> GetQueue(int retries = 1, TimeSpan? workItemTimeout = null, TimeSpan? retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true) {
            if (_queue == null)
                _queue = new InMemoryQueue<SimpleWorkItem>(retries, retryDelay, workItemTimeout: workItemTimeout, loggerFactory: Log);

            _logger.Debug("Queue Id: {queueId}", _queue.QueueId);
            return _queue;
        }

 public PlainWorkerPool(IQueue workQueue, int nWorkers)
 {
     this.nWorkers = nWorkers;
     this.workQueue = workQueue;
     for (int i = 0; i < nWorkers; ++i)
         activate();
 }

 public ThrottleBotsPlugin(ICacheClient cacheClient, IEventRepository eventRepository, IProjectRepository projectRepository, IMetricsClient metricsClient, IQueue<WorkItemData> workItemQueue) {
     _cacheClient = cacheClient;
     _metricsClient = metricsClient;
     _eventRepository = eventRepository;
     _projectRepository = projectRepository;
     _workItemQueue = workItemQueue;
 }

        internal AudioscrobblerConnection(IQueue queue)
        {
            LastfmCore.Account.Updated += AccountUpdated;

            state = State.Idle;
            this.queue = queue;
        }

        /// <summary>
        /// Record from a queue. The only real use case for this record as of now.
        /// </summary>
        /// <param name="queue">The queue to create this record from.</param>
        public ContextSwitchRecord(IQueue queue)
        {
            Process next = queue.GetContextSwitch();
            this.Ready = new List<ProcessRecord>();
            this.IO = new List<ProcessRecord>();
            this.Complete = new List<ProcessRecord>();

            this.Running = null;
            if (next != null && queue.State != QueueState.COMPLETE) this.Running = new ProcessRecord(next.Name, next.Parent.Name, next.Time.Current.Duration);
            this.Time = queue.TotalTime - 1;        //-1 because we're checking this AFTER it has incremented times.

            foreach (Process p in queue.CompleteProcs)
            {
                ProcessRecord add = new ProcessRecord()
                {
                    Name = p.Name,
                    Parent = p.Parent.Name,
                    CurrentTime = p.Time.Current == null ? 0 : p.Time.Current.Duration
                };
                this.Complete.Add(add);
            }

            foreach (Process p in queue.IOProcs) this.IO.Add(new ProcessRecord(p.Name, p.Parent.Name, p.Time.Current.Duration));

            foreach (Process p in queue.ReadyProcs)
            {
                if(p != next) this.Ready.Add(new ProcessRecord(p.Name, p.Parent.Name, p.Time.Current.Duration));
            }
        }

 public void AddPool(IQueue<PacketEventArgs> item)
 {
     if (!this.container.Contains<IQueue<PacketEventArgs>>(item))
     {
         this.container.Add(item);
     }
 }

        public DistributeMessageEventArgs(PipelineEvent pipelineEvent, IQueue destinationQueue,
		                                  TransportMessage transportMessage)
            : base(pipelineEvent)
        {
            DestinationQueue = destinationQueue;
            TransportMessage = transportMessage;
        }

        public ReceivePipelineExceptionModule(IQueue inboxWorkQueue)
        {
            Guard.AgainstNull(inboxWorkQueue, "inboxWorkQueue");

            this.inboxWorkQueue = inboxWorkQueue;

            log = Log.For(this);
        }

 public MyAppElasticConfiguration(IQueue<WorkItemData> workItemQueue, ICacheClient cacheClient, IMessageBus messageBus, ILoggerFactory loggerFactory) : base(workItemQueue, cacheClient, messageBus, loggerFactory) {
     AddIndex(Identities = new IdentityIndex(this));
     AddIndex(Employees = new EmployeeIndex(this));
     AddIndex(MonthlyEmployees = new MonthlyEmployeeIndex(this, 1));
     AddIndex(DailyLogEvents = new DailyLogEventIndex(this));
     AddIndex(MonthlyLogEvents = new MonthlyLogEventIndex(this));
     AddIndex(ParentChild = new ParentChildIndex(this));
 }

        public ResolvedQueue(IQueue queue, Uri uri)
        {
            Guard.AgainstNull(queue,"queue");
            Guard.AgainstNull(uri, "uri");

            _queue = queue;
            Uri = uri;
        }

        public static void Main(string[] args) {
            Console.CursorVisible = false;
            StartDisplayingLogMessages();

            var muxer = ConnectionMultiplexer.Connect("localhost");
            _queue = new RedisQueue<PingRequest>(muxer);

            var tokenSource = new CancellationTokenSource();
            CancellationToken token = tokenSource.Token;

            WriteOptionsMenu();

            while (true) {
                Console.SetCursorPosition(0, OPTIONS_MENU_LINE_COUNT + 1);
                ConsoleKeyInfo keyInfo = Console.ReadKey(true);

                if (keyInfo.Key == ConsoleKey.D1)
                    EnqueuePing();
                else if (keyInfo.Key == ConsoleKey.D2)
                    EnqueuePing(100);
                //else if (keyInfo.Key == ConsoleKey.D3)
                //    EnqueueContinuousPings(50, token, 100);
                //else if (keyInfo.Key == ConsoleKey.D4)
                //    EnqueueContinuousPings(50, token, 100);
                else if (keyInfo.Key == ConsoleKey.Q)
                    break;
                else if (keyInfo.Key == ConsoleKey.S) {
                    tokenSource.Cancel();
                    tokenSource = new CancellationTokenSource();
                    token = tokenSource.Token;
                    ClearOutputLines();
                }
            }
        }