public DefaultCleanAggregateService(IMemoryCache memoryCache, IScheduleService scheduleService)
 {
     TimeoutSeconds = ENodeConfiguration.Instance.Setting.AggregateRootMaxInactiveSeconds;
     _memoryCache = memoryCache;
     _scheduleService = scheduleService;
     _scheduleService.StartTask("CleanAggregates", Clean, 1000, ENodeConfiguration.Instance.Setting.ScanExpiredAggregateIntervalMilliseconds);
 }

 public MessageHandler()
 {
     _scheduleService = ObjectContainer.Resolve<IScheduleService>();
     _scheduleService.StartTask("PrintThroughput", PrintThroughput, 1000, 1000);
     _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(typeof(Program).Name);
     _throughputLogger = ObjectContainer.Resolve<ILoggerFactory>().Create("throughput");
 }

 public DisplayLunchViewModel(IScheduleService service)
 {
     this.Service = service;
     this.Week = new ObservableCollection<LunchTimeDto>();
     this.WeekView = CollectionViewSource.GetDefaultView(Week);
     this.WeekView.GroupDescriptions.Add(new PropertyGroupDescription("DayOfWeek"));
 }

 public DefaultEventService(
     IJsonSerializer jsonSerializer,
     IScheduleService scheduleService,
     ITypeNameProvider typeNameProvider,
     IMemoryCache memoryCache,
     IAggregateRootFactory aggregateRootFactory,
     IAggregateStorage aggregateStorage,
     IEventStore eventStore,
     IMessagePublisher<DomainEventStreamMessage> domainEventPublisher,
     IOHelper ioHelper,
     ILoggerFactory loggerFactory)
 {
     _eventMailboxDict = new ConcurrentDictionary<string, EventMailBox>();
     _ioHelper = ioHelper;
     _jsonSerializer = jsonSerializer;
     _scheduleService = scheduleService;
     _typeNameProvider = typeNameProvider;
     _memoryCache = memoryCache;
     _aggregateRootFactory = aggregateRootFactory;
     _aggregateStorage = aggregateStorage;
     _eventStore = eventStore;
     _domainEventPublisher = domainEventPublisher;
     _logger = loggerFactory.Create(GetType().FullName);
     _batchSize = ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize;
 }

 public MessageService(IMessageStore messageStore, IOffsetManager offsetManager, IScheduleService scheduleService)
 {
     _messageStore = messageStore;
     _offsetManager = offsetManager;
     _scheduleService = scheduleService;
     _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
 }

        public ChunkWriter(ChunkManager chunkManager)
        {
            Ensure.NotNull(chunkManager, "chunkManager");

            _chunkManager = chunkManager;
            _scheduleService = ObjectContainer.Resolve<IScheduleService>();
        }

 public ScheduleController(IRepository repository, IScheduleService schedService, ITruckService truckService, IMappingEngine mapper)
 {
     this.repository = repository;
     this.schedService = schedService;
     this.truckService = truckService;
     this.mapper = mapper;
 }

 public ActivityGridViewModel(IScheduleService service)
 {
     this.Service = service;
     this.Activities = new ObservableCollection<ActivityModel>();
     this.ActivitiesView = CollectionViewSource.GetDefaultView(Activities);
     this.ActivitiesView.GroupDescriptions.Add(new PropertyGroupDescription("DayOfWeek"));
 }

        public Consumer(string groupName, ConsumerSetting setting)
        {
            if (groupName == null)
            {
                throw new ArgumentNullException("groupName");
            }
            GroupName = groupName;
            Setting = setting ?? new ConsumerSetting();

            _lockObject = new object();
            _subscriptionTopics = new Dictionary<string, HashSet<string>>();
            _topicQueuesDict = new ConcurrentDictionary<string, IList<MessageQueue>>();
            _pullRequestDict = new ConcurrentDictionary<string, PullRequest>();
            _remotingClient = new SocketRemotingClient(Setting.BrokerAddress, Setting.SocketSetting, Setting.LocalAddress);
            _adminRemotingClient = new SocketRemotingClient(Setting.BrokerAdminAddress, Setting.SocketSetting, Setting.LocalAdminAddress);
            _binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
            _scheduleService = ObjectContainer.Resolve<IScheduleService>();
            _allocateMessageQueueStragegy = ObjectContainer.Resolve<IAllocateMessageQueueStrategy>();
            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);

            _remotingClient.RegisterConnectionEventListener(new ConnectionEventListener(this));

            if (Setting.MessageHandleMode == MessageHandleMode.Sequential)
            {
                _consumingMessageQueue = new BlockingCollection<ConsumingMessage>();
                _consumeMessageWorker = new Worker("ConsumeMessage", () => HandleMessage(_consumingMessageQueue.Take()));
            }
            _messageRetryQueue = new BlockingCollection<ConsumingMessage>();
        }

        public Consumer(string id, string groupName, ConsumerSetting setting)
        {
            if (id == null)
            {
                throw new ArgumentNullException("id");
            }
            if (groupName == null)
            {
                throw new ArgumentNullException("groupName");
            }
            Id = id;
            GroupName = groupName;
            Setting = setting ?? new ConsumerSetting();

            _lockObject = new object();
            _subscriptionTopics = new List<string>();
            _topicQueuesDict = new ConcurrentDictionary<string, IList<MessageQueue>>();
            _pullRequestQueue = new BlockingCollection<PullRequest>(new ConcurrentQueue<PullRequest>());
            _pullRequestDict = new ConcurrentDictionary<string, PullRequest>();
            _consumingMessageQueue = new BlockingCollection<ConsumingMessage>(new ConcurrentQueue<ConsumingMessage>());
            _messageRetryQueue = new BlockingCollection<ConsumingMessage>(new ConcurrentQueue<ConsumingMessage>());
            _handlingMessageDict = new ConcurrentDictionary<long, ConsumingMessage>();
            _taskIds = new List<int>();
            _remotingClient = new SocketRemotingClient(Setting.BrokerAddress, Setting.BrokerPort);
            _binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
            _scheduleService = ObjectContainer.Resolve<IScheduleService>();
            _allocateMessageQueueStragegy = ObjectContainer.Resolve<IAllocateMessageQueueStrategy>();
            _executePullRequestWorker = new Worker("Consumer.ExecutePullRequest", ExecutePullRequest);
            _handleMessageWorker = new Worker("Consumer.HandleMessage", HandleMessage);
            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
        }

        public ClientService(ClientSetting setting, Producer producer, Consumer consumer)
        {
            Ensure.NotNull(setting, "setting");
            if (producer == null && consumer == null)
            {
                throw new ArgumentException("producer or consumer must set at least one of them.");
            }
            else if (producer != null && consumer != null)
            {
                throw new ArgumentException("producer or consumer cannot set both of them.");
            }

            Interlocked.Increment(ref _instanceNumber);

            _producer = producer;
            _consumer = consumer;
            _setting = setting;
            _clientId = BuildClientId(setting.ClientName);
            _brokerConnectionDict = new ConcurrentDictionary<string, BrokerConnection>();
            _topicMessageQueueDict = new ConcurrentDictionary<string, IList<MessageQueue>>();
            _binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
            _jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
            _scheduleService = ObjectContainer.Resolve<IScheduleService>();
            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
            _nameServerRemotingClientList = RemotingClientUtils.CreateRemotingClientList(_setting.NameServerList, _setting.SocketSetting).ToList();
        }

        public Consumer(string groupName, ConsumerSetting setting)
        {
            if (groupName == null)
            {
                throw new ArgumentNullException("groupName");
            }
            GroupName = groupName;
            Setting = setting ?? new ConsumerSetting();

            _lockObject = new object();
            _subscriptionTopics = new Dictionary<string, HashSet<string>>();
            _topicQueuesDict = new ConcurrentDictionary<string, IList<MessageQueue>>();
            _pullRequestQueue = new BlockingCollection<PullRequest>(new ConcurrentQueue<PullRequest>());
            _pullRequestDict = new ConcurrentDictionary<string, PullRequest>();
            _messageRetryQueue = new BlockingCollection<ConsumingMessage>(new ConcurrentQueue<ConsumingMessage>());
            _taskFactory = new TaskFactory(new LimitedConcurrencyLevelTaskScheduler(Setting.ConsumeThreadMaxCount));
            _remotingClient = new SocketRemotingClient(Setting.BrokerAddress, Setting.SocketSetting, Setting.LocalAddress);
            _adminRemotingClient = new SocketRemotingClient(Setting.BrokerAdminAddress, Setting.SocketSetting, Setting.LocalAdminAddress);
            _binarySerializer = ObjectContainer.Resolve<IBinarySerializer>();
            _scheduleService = ObjectContainer.Resolve<IScheduleService>();
            _allocateMessageQueueStragegy = ObjectContainer.Resolve<IAllocateMessageQueueStrategy>();
            _executePullRequestWorker = new Worker("ExecutePullRequest", ExecutePullRequest);
            _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);

            _remotingClient.RegisterConnectionEventListener(new ConnectionEventListener(this));
        }

        public ScheduleDisplayViewModel(IScheduleService service)
        {
            this.RefreshDatesCommand = new RelayCommand(RefreshDates);

            this.Mondays = new ObservableCollection<DateTime>();
            this.Service = service;
        }

 public ExaminationDatasheetsController(IGroupService gs, ICourseService cs, IAcademicProgressService aps,
     IScheduleService scs)
 {
     groupService = gs;
     courseService = cs;
     academicProgressService = aps;
     scheduleService = scs;
 }

 public SendReplyService()
 {
     _clientWrapperDict = new ConcurrentDictionary<string, SocketRemotingClientWrapper>();
     _jsonSerializer = ObjectContainer.Resolve<IJsonSerializer>();
     _scheduleService = ObjectContainer.Resolve<IScheduleService>();
     _ioHelper = ObjectContainer.Resolve<IOHelper>();
     _logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
 }

 public DefaultConsumeOffsetStore(IScheduleService scheduleService, IJsonSerializer jsonSerializer, ILoggerFactory loggerFactory)
 {
     _groupConsumeOffsetsDict = new ConcurrentDictionary<string, ConcurrentDictionary<QueueKey, long>>();
     _groupNextConsumeOffsetsDict = new ConcurrentDictionary<string, ConcurrentDictionary<QueueKey, long>>();
     _scheduleService = scheduleService;
     _jsonSerializer = jsonSerializer;
     _logger = loggerFactory.Create(GetType().FullName);
 }

 public DefaultConsumeOffsetStore(IScheduleService scheduleService, IJsonSerializer jsonSerializer, ILoggerFactory loggerFactory)
 {
     _groupConsumeOffsetsDict = new ConcurrentDictionary<string, ConcurrentDictionary<string, long>>();
     _scheduleService = scheduleService;
     _jsonSerializer = jsonSerializer;
     _logger = loggerFactory.Create(GetType().FullName);
     _persistConsumeOffsetTaskName = string.Format("{0}.PersistConsumeOffsetInfo", this.GetType().Name);
 }

 public DefaultQueueStore(IMessageStore messageStore, IConsumeOffsetStore consumeOffsetStore, IScheduleService scheduleService, ILoggerFactory loggerFactory)
 {
     _queueDict = new ConcurrentDictionary<string, Queue>();
     _messageStore = messageStore;
     _consumeOffsetStore = consumeOffsetStore;
     _scheduleService = scheduleService;
     _logger = loggerFactory.Create(GetType().FullName);
 }

 public MessageService(IBinarySerializer binarySerializer, IScheduleService scheduleService, SendEmailService sendEmailService)
 {
     _nameServerRemotingClientList = CreateRemotingClientList(Settings.NameServerList);
     _clusterBrokerDict = new ConcurrentDictionary<string, IList<BrokerClient>>();
     _binarySerializer = binarySerializer;
     _scheduleService = scheduleService;
     _sendEmailService = sendEmailService;
 }

        public ChunkWriter(ChunkManager chunkManager)
        {
            Ensure.NotNull(chunkManager, "chunkManager");

            _chunkManager = chunkManager;
            _scheduleService = ObjectContainer.Resolve<IScheduleService>();
            _flushTaskName = string.Format("{0}-FlushChunk", _chunkManager.Name);
        }