public Program(IMessageSender sender, IStoreEvents store, NuclearStorage storage)
 {
     this.sender = new SenderDecorator(sender);
     this.store = store;
     this.storage = storage;
     reader = new ConsoleReader();
 }

 public InteractionProcessor(IMessageSender sender, LifelineViewport viewport, NuclearStorage storage)
 {
     _sender = sender;
     _viewport = viewport;
     _storage = storage;
     CurrentStoryId = new StoryId(Guid.Empty);
 }

        public EventStoreBusPublisher(IMessageSender sender, IPendingEventsQueue queue)
        {
            this.sender = sender;
            this.queue = queue;

            this.enqueuedKeys = new BlockingCollection<string>();
        }

 public void Invoke(IMessageSender sender, Message message)
 {
     foreach(var listener in Listeners)
     {
         listener.Value.Invoke(listener.Key, sender, message);
     }
 }

 public void CreateBus()
 {
     m_Sender = Substitute.For<IMessageSender>();
     m_Receiver = Substitute.For<IMessageReceiver>();
     m_Bus = new MessageBus(m_Sender,
                            m_Receiver);
 }

        static MessageService()
        {
            if (!MessagingEnabled) return;

            var unitySection = ConfigurationManager.GetSection("unity");
            if (unitySection == null)
            {
                log.Error("Required unity configuration for Message Sender");
                return;
            }

            try
            {
                var unity = new UnityContainer().LoadConfiguration(unityContainerName);
                if (unity.IsRegistered<IMessageSender>())
                {
                    sender = unity.Resolve<IMessageSender>();
                }
                else
                {
                    log.Error("Required unity configuration for Message Sender");
                }
            }
            catch(Exception ex)
            {
                log.Error("Error while resolving Message Sender: " + ex);
            }
        }

 public ProtocolChoicePromptHandler(
     IMessageSender messageSender,
     ConsoleService consoleService)
 {
     this.messageSender = messageSender;
     this.consoleService = consoleService;
 }

 public TransportClient(IMessageSender messageSender, IMessageListener messageListener, ILogger logger, ISerializer<byte[]> serializer)
 {
     _messageSender = messageSender;
     _messageListener = messageListener;
     _logger = logger;
     _serializer = serializer;
     messageListener.Received += MessageListener_Received;
 }

 public HttpMessageWriter(IMessageSender messageSender, string baseUrl, OutputPort light, Watchdog[] resetWatchdogsOnSend)
 {
     _messageSender = messageSender;
     _baseUrl = baseUrl;
     _light = light;
     _resetWatchdogsOnSend = resetWatchdogsOnSend ?? new Watchdog[] {};
     StartThread();
 }

 public TransportClient(IMessageSender messageSender, IMessageListener messageListener, ILogger logger, IServiceExecutor serviceExecutor)
 {
     _messageSender = messageSender;
     _messageListener = messageListener;
     _logger = logger;
     _serviceExecutor = serviceExecutor;
     messageListener.Received += MessageListener_Received;
 }

 public IncomingMessageProcessor(IRepository repository, IMessageSender messageSender,
                                 ICaseRepository caseRepository, IEmailSender emailSender)
 {
     _repository = repository;
     _messageSender = messageSender;
     _caseRepository = caseRepository;
     _emailSender = emailSender;
 }

 public IMessageSender GetSender(IMessageSender[] senders)
 {
     lock (_sendersLock)
     {
         _currentSender = ++_currentSender % senders.Length;
         return senders[_currentSender];
     }
 }

		private void SendAll(IEnumerable messages, IMessageSender sender)
		{
			IEnumerator iterator = messages.GetEnumerator();
			while (iterator.MoveNext())
			{
				sender.Send(iterator.Current);
			}
		}

 public EventBus(IMessageSender messageSender,
     IRoutingKeyProvider routingKeyProvider,
     IMetadataProvider metadataProvider)
 {
     this.messageSender = messageSender;
     this.routingKeyProvider = routingKeyProvider;
     this.metadataProvider = metadataProvider;
     this.logger = LogManager.GetLogger("ThinkNet");
 }

        public override void Given()
        {
            messageSender = Moq.Mock<IMessageSender>();

            var messageMap = Moq.Mock<IMessageMap_v2>();
            messageMap.SetupGet(x => x.MessageType).Returns(typeof(ChangeOrderAttributes));

            viewModel = new MessageMapViewModel(messageSender, messageMap);
        }

        /// <summary>
        /// Azures the index builder.
        /// </summary>
        /// <param name="repository">The repository.</param>
        /// <param name="searchProvider">The search provider.</param>
        /// <param name="messageSender">The message sender.</param>
        /// <param name="consumerFactory">The consumer factory.</param>
        /// <param name="observer">The observer.</param>
        /// <param name="queueReader">The queue reader.</param>
        /// <param name="indexBuilders">The index builders.</param>
        public SearchIndexController(IBuildSettingsRepository repository, ISearchProvider searchProvider, IMessageSender messageSender, IConsumerFactory consumerFactory, ISystemObserver observer, IQueueReader queueReader, ISearchIndexBuilder[] indexBuilders)
		{
			_repository = repository;
			_messageSender = messageSender;
			_observer = observer;
			_queueReader = queueReader;
			_consumerFactory = consumerFactory;
            _searchProvider = searchProvider;
            _indexBuilders = indexBuilders;
		}

        public ProxyService(IHmrcDataManipulator dataManipulator, IConfigurationRepository configRepository, IMessageSender messageSender)
        {
            if (dataManipulator == null) throw new ArgumentNullException(nameof(dataManipulator));
            if (configRepository == null) throw new ArgumentNullException(nameof(configRepository));
            if (messageSender == null) throw new ArgumentNullException(nameof(messageSender));

            this.dataManipulator = dataManipulator;
            this.configRepository = configRepository;
            this.messageSender = messageSender;
        }

 public static void RegisterView(IMessageSender viewModel)
 {
     Type viewModelType = viewModel.GetType();
     if (_views.ContainsKey(viewModelType))
     {
         IMessageListener listener = Activator.CreateInstance(_views[viewModelType]) as IMessageListener;
         listener.Initialize(viewModel);
         _registeredViews.Add(listener);
     }
 }

 public BusBootstrapper(IAssemblyScanner assemblyScanner, ZmqTransportConfiguration zmqTransportConfiguration, IBusBootstrapperConfiguration bootstrapperConfiguration,
     IMessageSender messageSender, IPeerManager peerManager, ISubscriptionManager subscriptionManager, IPeerConfiguration peerConfiguration)
 {
     _assemblyScanner = assemblyScanner;
     _zmqTransportConfiguration = zmqTransportConfiguration;
     _bootstrapperConfiguration = bootstrapperConfiguration;
     _messageSender = messageSender;
     _peerManager = peerManager;
     _subscriptionManager = subscriptionManager;
     _peerConfiguration = peerConfiguration;
 }

 public CommandBus(IMessageSender messageSender,
     ICommandResultManager commandResultManager,
     IRoutingKeyProvider routingKeyProvider,
     IMetadataProvider metadataProvider)
 {
     this.messageSender = messageSender;
     this.commandResultManager = commandResultManager;
     this.routingKeyProvider = routingKeyProvider;
     this.metadataProvider = metadataProvider;
     this.logger = LogManager.GetLogger("ThinkNet");
 }