public Session(IReceiver receiver, IAnalysis analysis)
        {
            Id = Guid.NewGuid();
            Receiver = receiver;

            DiagnoseOutputEntries = new ReactiveCollection<IDiagnoseOutputEntry>();
            Analysis = new ReactiveCollection<IAnalysis>();

            Analysis.ItemsAdded.Subscribe(x =>
                {
                    foreach (var diagnoseOutputEntry in DiagnoseOutputEntries)
                    {
                        x.ProcessNewDiagnoseOutputEntry(diagnoseOutputEntry);
                    }
                });

            Analysis.Add(analysis);

            DiagnoseOutputEntries.ItemsAdded.Subscribe(x =>
                {
                    foreach (var analyse in Analysis)
                    {
                        analyse.ProcessNewDiagnoseOutputEntry(x);
                    }
                });
        }

 public void StartReceiving(IReceiver receiver, ILogger logger)
 {
     Scheduler.Start(() =>
     {
         int exceptionCount = 0;
         var receivingState = ReceivingState.CanContinueReceiving;
         while (receivingState == ReceivingState.CanContinueReceiving)
         {
             try
             {
                 receivingState = Channel.Receive(receiver);
                 exceptionCount = 0;
             }
             catch (Exception ex)
             {
                 logger.InfoMessage(new ReceiveFailed { ChannelKey = Key, Exception = ex });
                 logger.Error("Error in receive loop", ex);
                 if (++exceptionCount > 9)
                 {
                     // We're probably stuck getting the same error forever, let the process crash.
                     throw new ReceiveFailureException(
                         "Received repeated errors while listening for messages on channel: " + Key,
                         ex);
                 }
             }
         }
     });
 }

        static Invoker VoiceCall, VideoCall, Chat; //Add more commands here

        #endregion Fields

        #region Constructors

        public Command(IReceiver receiver, CommandType type)
        {
            VoiceCall = receiver.MakeAVoiceCall;
            VideoCall = receiver.MakeAVideoCall;
            Chat = receiver.StartChat;
            SendFile = receiver.SendFile;
            Type = type;
        }

        public Guid AddSession(IReceiver receiver, IAnalysis analysis)
        {
            var newSession = new Session(receiver, analysis);

            Sessions.Add(newSession);

            return newSession.Id;
        }

 public ReceiveDataHandler(Topic t, Participant part, IReceiver receiver)
 {
     topic = t;
     bytes = new byte[t.GetSampleMaxSize()];
     headerBytes = new byte[FRAGMENT_HEADER_SIZE];
     participant = part;
     fragmentSize = Globals.MAX_SEGMENT_SIZE;
     this.receiver = receiver;
 }

		public void SetUp()
		{
			Helper.SetupTestMessaging();
			mock_event_hook = Substitute.For<IEventHook>();

			ObjectFactory.Configure(map=> map.For<IEventHook>().Use(mock_event_hook));

			node_factory = ObjectFactory.GetInstance<IReceiver>();
		}

 private void AddReceiver(IReceiver receiver)
 {
   string displayName = String.IsNullOrEmpty(receiver.DisplayName)
                            ? ReceiverUtils.GetTypeDescription(receiver.GetType())
                            : receiver.DisplayName;
   ListViewItem lvi = receiversListView.Items.Add(displayName);
   lvi.Tag = receiver;
   lvi.Selected = true;
 }

 public ReceivingState Receive(IReceiver receiver)
 {
     var stream = _queueManager.ReceiveStream(_queueName);
     foreach (var message in stream.TakeWhile(message => !_disposed))
     {
         receiver.Receive(message.Message.Data, new NameValueHeaders(message.Message.Headers),
             new TransactionCallback(message.TransactionalScope, message.Message, _delayedMessages));
     }
     return ReceivingState.StopReceiving;
 }

        protected override void SetUp()
        {
            var fiber = new StubFiber();

            _mock_first = CreateMock<IReceiver<int>>();
            _mock_rest = CreateMock<IReceiver<int>>();

            _receiver = new FirstReceiver<int>(fiber,
                _mock_first.Object, _mock_rest.Object);
        }

 public override Command CreateCommand(ConsoleKeyInfo keyInfo, IReceiver receiver)
 {
     switch (keyInfo.Key)
     {
         case ConsoleKey.Enter:
             return new SubmitCommand(receiver);
         case ConsoleKey.Backspace:
             return new BackspaceCommand(receiver);
         default:
             return new InputCharacterCommand(keyInfo.KeyChar, receiver);
     }
 }

        public ChatConsoleActor(string userName,string clientActorPath)
        {
            _userName = userName;
            _clientActorPath = clientActorPath;

            _clientActor = ActorSystemContainer.Instance.System.ActorSelection(_clientActorPath).ResolveOne(new TimeSpan(0, 0, 10)).Result;
            _clientActor.Tell(new Messages.AttachConsole(Self));
            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "actor", _clientActor }, { "userName", _userName } };
            //Dictionary<string, object> parameters = new Dictionary<string, object>() { { "filePath", @"c:\logs\fileoutput.txt" } };
            _receiver = GlobalIocContainer.Container.IocContainer.Resolve<IReceiver>(parameters);
            _commandFactory = GlobalIocContainer.Container.IocContainer.Resolve<CommandFactory>();
            _commandManager = new CommandManager();
        }

        public MessageBroker(IChannel channel, IWorker worker, IReceiver[] receivers, Configuration.HostSection config)
        {
            this.channel = channel;
            this.worker = worker;
            this.receivers = receivers.ToLookup(r => r.MessageType);

            this.Name = config.Messaging.SenderName;
            this.Enabled = config.Messaging.Enabled;
            this.Async = config.Messaging.Async;
            this.OnlyFromMachineNamed = config.Messaging.Targets.OnlyFromMachineNamed;
            this.SharedSecret = config.Messaging.Targets.SharedSecret;
            this.Targets = config.Messaging.Targets.AllElements.Select(te => new MessageTarget { Name = te.Name, Address = te.Address, ExceptFromMachineNamed = te.ExceptFromMachineNamed }).ToArray();
        }

        public ReceivingState Receive(IReceiver receiver)
        {
            _disposable = _queueManager.Receive(_queueName).Subscribe(message =>
            {
                Task.Run(() =>
                {
                    receiver.Receive(message.Message.Data, new DictionaryHeaders(message.Message.Headers),
                        new TransactionCallback(message.QueueContext, message.Message));
                });
            });

            return ReceivingState.StopReceiving;
        }

 public static IReceiver GetReceiver()
 {
     if(_receiver == null)
     {
         try
         {
             _receiver = new UDPReceiver();
         }
         catch (System.Exception ex)
         {
             throw new Exception(ex.Message);
         }
     }
     return _receiver;
 }

        public void Receive(IReceiver receiver)
        {
            while (!_disposed)
            {
                foreach (var data in _queue.GetConsumingEnumerable())
                {
                    using (var stream = new MemoryStream(data))
                    {
                        var token = _formatter.Deserialize(stream).As<EnvelopeToken>();

                        var callback = new InMemoryCallback(this, token);

                        receiver.Receive(token.Data, token.Headers, callback);
                    }
                }
            }
        }

 public PressHome(IReceiver aReceiver )
 {
     myReceiver= aReceiver ;
 }

 protected CharacterAction(IReceiver receiver)
 {
     Receiver = receiver;
     IsExecuted = false;
 }

 private void TerminateReceiver(IReceiver receiver)
 {
     try
       {
     receiver.Detach();
     receiver.Terminate();
       }
       catch (Exception ex)
       {
     ShowErrorBox("Failed to Terminate Receiver: " + ex.Message);
       }
 }

        private void InitializeReceiver(IReceiver receiver)
        {
            try
              {
            receiver.Initialize();
            receiver.Attach(this);

            //LogManager.Instance.SetRootLoggerName(String.Format("Root [{0}]", receiver));
              }
              catch (Exception ex)
              {
            try
            {
              receiver.Terminate();
            }
            catch { }

            ShowErrorBox("Failed to Initialize Receiver: " + ex.Message);
              }
        }

 internal Receiver(IReceiver aReceiver)
 {
     iReceiver = aReceiver;
     iDescription = iReceiver.Room + " (" + iReceiver.Group + ")";
 }