public BreakpointsViewModel(IBus bus)
            : base(bus)
        {
            Contract.Requires<ArgumentNullException>(bus != null);

            this.Title = "Breakpoints";
        }

    static void SendOrder(IBus bus)
    {

        Console.WriteLine("Press enter to send a message");
        Console.WriteLine("Press any key to exit");

        while (true)
        {
            ConsoleKeyInfo key = Console.ReadKey();
            Console.WriteLine();

            if (key.Key != ConsoleKey.Enter)
            {
                return;
            }
            Guid id = Guid.NewGuid();

            PlaceOrder placeOrder = new PlaceOrder
            {
                Product = "New shoes",
                Id = id
            };
            bus.Send("Samples.StepByStep.Server", placeOrder);

            Console.WriteLine("Sent a new PlaceOrder message with id: {0}", id.ToString("N"));

        }

    }

 public void SetupMessaging(IBus coreInputBus)
 {
     coreInputBus.Subscribe<ProjectionCoreServiceMessage.Start>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionCoreServiceMessage.Stop>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionCoreServiceMessage.Tick>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepare>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.CreatePrepared>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.Dispose>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionSubscriptionManagement.Subscribe>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionSubscriptionManagement.Unsubscribe>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionSubscriptionManagement.Pause>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionSubscriptionManagement.Resume>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionCoreServiceMessage.CommittedEventDistributed>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionCoreServiceMessage.EventReaderIdle>(_projectionCoreService);
     coreInputBus.Subscribe<ProjectionCoreServiceMessage.EventReaderEof>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.Start>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.LoadStopped>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.Stop>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.Kill>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.GetState>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.GetDebugState>(_projectionCoreService);
     coreInputBus.Subscribe<CoreProjectionManagementMessage.UpdateStatistics>(_projectionCoreService);
     coreInputBus.Subscribe<ClientMessage.ReadStreamEventsBackwardCompleted>(_projectionCoreService);
     coreInputBus.Subscribe<ClientMessage.WriteEventsCompleted>(_projectionCoreService);
     //NOTE: message forwarding is set up outside (for Read/Write events)
 }

		public DocumentSearchViewModel(IBus bus, IEventAggregator eventAggregator)
		{
			if (bus == null) throw new ArgumentNullException("bus");
			if (eventAggregator == null) throw new ArgumentNullException("eventAggregator");
			_Bus = bus;
			_EventAggregator = eventAggregator;
		}

 public AppointmentController(
     IBus bus,
     IAppointmentService appointmentService)
 {
     _bus = bus;
     _appointmentService = appointmentService;
 }

 public SchedulerService(IBus bus, IEasyNetQLogger log, IScheduleRepository scheduleRepository, ISchedulerServiceConfiguration configuration)
 {
     this.bus = bus;
     this.log = log;
     this.scheduleRepository = scheduleRepository;
     this.configuration = configuration;
 }

 public MessageBusReplySessionChannel(
     BufferManager bufferManager, MessageEncoderFactory encoderFactory, ChannelManagerBase parent,
     EndpointAddress localAddress,
     IBus bus)
     : base(bufferManager, encoderFactory, parent, localAddress, bus)
 {
 }

        public MessageBusInputChannel(
            BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent,
            EndpointAddress localAddress,
            IBus bus)
            : base(bufferManager, encoder, parent)
        {
            _localAddress = localAddress;
            _bus = bus;
            _aLock = new object();

            _tryReceiveDelegate = (TimeSpan timeout, out Message message) =>
            {
                message = null;
                try
                {
                    var requestMessage = _bus.Receive(true, null);
                    if (requestMessage != null)
                    {
                        message = GetWcfMessageFromString(requestMessage.Content);
                        OnAfterTryReceive(requestMessage);
                    }
                }
                catch (Exception ex)
                {
                    throw new CommunicationException(ex.Message, ex);
                }
                return true;
            };

            _receiveDelegate = (TimeSpan timeout) =>
            {
                var requestMessage = _bus.Receive(false, ChannelID);
                return GetWcfMessageFromString(requestMessage.Content);
            };
        }

 public static void InitializeWith(this IEnumerable<ISaga> sagas, IBus bus)
 {
     foreach (var saga in sagas)
     {
         saga.Initialize(bus);
     }
 }

    public static void Main()
    {
        BusG.Init ();
        Application.Init ();

        tv = new TextView ();
        ScrolledWindow sw = new ScrolledWindow ();
        sw.Add (tv);

        Button btn = new Button ("Click me");
        btn.Clicked += OnClick;

        Button btnq = new Button ("Click me (thread)");
        btnq.Clicked += OnClickQuit;

        VBox vb = new VBox (false, 2);
        vb.PackStart (sw, true, true, 0);
        vb.PackStart (btn, false, true, 0);
        vb.PackStart (btnq, false, true, 0);

        Window win = new Window ("D-Bus#");
        win.SetDefaultSize (640, 480);
        win.Add (vb);
        win.Destroyed += delegate {Application.Quit ();};
        win.ShowAll ();

        bus = Bus.Session.GetObject<IBus> ("org.freedesktop.DBus", new ObjectPath ("/org/freedesktop/DBus"));

        Application.Run ();
    }

 protected override void Given()
 {
     sr = Substitute.For<SourceRepoDriver>();
     sr.GetLatestRevision().Returns(new RevisionInfo { Revision = "456" });
     bus = Substitute.For<IBus>();
     rc = new Domain.RevisionChecker(bus, url => sr);
 }

 void Shutdown(IBus bus)
 {
     #region Hosting-Shutdown
     UnicastBus busImpl = (UnicastBus)bus;
     busImpl.Dispose();
     #endregion
 }

        void InterfaceMessage(IBus bus)
        {
            #region InterfacePublish
            bus.Publish<IMyEvent>(m => { m.SomeProperty = "Hello world"; });
            #endregion

        }

        public NotificationService(IBus bus, ILogger logger, ILogEventBuilder eventBuilder)
        {
            _repository = new NotificationRepository();
            _notificationPlayerRepository = new NotificationPlayerRepository();
            _notificationRepository = new NotificationRepository();
            //_publisher = new RabbitMqPublisher()
            //{
            //    MessageLookups = new List<MessageConfig>()
            //    {
            //        new MessageConfig()
            //        {
            //            ExchangeName = "PB.Events",
            //            MessageType = typeof (NotificationCreated),
            //            RoutingKey = ""
            //        }
            //    }
            //};

            _bus = bus;
            _logger = logger;
            _eventBuilder = eventBuilder;

            _publisher = new RabbitMqPublisher(ConfigurationManager.AppSettings["Queue.Uri"])
            {
                MessageLookups = new List<MessageConfig>()
                {
                    new MessageConfig()
                    {
                        ExchangeName = "PB.Events",
                        MessageType = typeof (NotificationCreated),
                        RoutingKey = ""
                    }
                }
            };
        }

        public void Setup()
        {
            _bus = MockRepository.GenerateStub<IBus>();
            _productRenamedEventHandler = new ProductRenamedEventHandler(_bus);

            _productId = Guid.NewGuid();
        }

 public SchedulerService(IBus bus, IRawByteBus rawByteBus, ILog log, IScheduleRepository scheduleRepository)
 {
     this.bus = bus;
     this.scheduleRepository = scheduleRepository;
     this.rawByteBus = rawByteBus;
     this.log = log;
 }

 public AccidentRecordService(IAccidentRecordRepository accidentRecordRepository,
                              IAccidentTypeRepository accidentTypeRepository,
                              ICauseOfAccidentRepository causeOfAccidentRepository,
                              IJurisdictionRepository jurisdictionRepository,
                              IUserForAuditingRepository userForAuditingRepository,
                              ICountriesRepository countriesRepository,
                              IEmployeeRepository employeeRepository,
                              ISiteRepository siteRepository,
                              IDocumentTypeRepository documentTypeRepository,
                              IInjuryRepository injuryRepository,
                              IBodyPartRepository bodyPartRepository,
                              IPeninsulaLog log,
                              IBus bus)
 {
     _accidentRecordRepository = accidentRecordRepository;
     _accidentTypeRepository = accidentTypeRepository;
     _causeOfAccidentRepository = causeOfAccidentRepository;
     _jurisdictionRepository = jurisdictionRepository;
     _userForAuditingRepository = userForAuditingRepository;
     _countriesRepository = countriesRepository;
     _employeeRepository = employeeRepository;
     _siteRepository = siteRepository;
     _documentTypeRepository = documentTypeRepository;
     _log = log;
     _injuryRepository = injuryRepository;
     _bodyPartRepository = bodyPartRepository;
     _bus = bus;
 }

        public void SetUp()
        {
            testSender = MockRepository.GenerateStub<ISendMessages>();

            messagePersister = new InMemoryPersistence();

            httpChannel = new HttpChannel(messagePersister)
                              {
                                  ListenUrl = "http://localhost:8092/Gateway/",
                                  ReturnAddress = "Gateway.Tests.Input"
                              };

            httpChannel.MessageReceived += httpChannel_MessageReceived;

            httpChannel.Start();

            bus = Configure.With()
                .DefaultBuilder()
                .XmlSerializer()
                .FileShareDataBus("./databus")
                .InMemoryFaultManagement()
                .UnicastBus()
                .MsmqTransport()
                .CreateBus()
                .Start();
        }

        public void SetUp()
        {
            container = new Container();
            container.RegisterAsEasyNetQContainerFactory();

            bus = new MockBuilder().Bus;
        }

        protected override void SetUp()
        {
            var logger = new ListLoggerFactory(detailed: true);

            // start the external timeout manager
            Configure.With(Using(new BuiltinHandlerActivator()))
                .Logging(l => l.Use(logger))
                .Transport(t => t.UseMsmq(_queueNameTimeoutManager))
                .Start();

            _gotTheMessage = new ManualResetEvent(false);

            // start the client
            var client = Using(new BuiltinHandlerActivator());

            client.Handle<string>(async str => _gotTheMessage.Set());

            Configure.With(client)
                .Logging(l => l.Use(logger))
                .Transport(t => t.UseMsmq(_queueName))
                .Options(o => o.UseExternalTimeoutManager(_queueNameTimeoutManager))
                .Start();

            _bus = client.Bus;
        }