C# IQueue类代码示例

 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;
        }

        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();
                }
            }
        }

 private StatusUpdater()
 {
     roverStatus = new RoverStatus();
     //timer = new System.Timers.Timer(Properties.Settings.Default.StatusUpdateInterval) { Enabled = false };
     updatesQueue = new PriorityQueue(100);
     listener = new MessageListener(Properties.NetworkSettings.Default.StatusUpdatePort, updatesQueue, Properties.NetworkSettings.Default.RoverIPAddress);
 }