public void Enqueue(IActorRef receiver, Envelope envelope)
 {
     if (!_queue.TryAdd(envelope, PushTimeOut)) // dump messages that can't be delivered in-time into DeadLetters
     {
         receiver.AsInstanceOf<IInternalActorRef>().Provider.DeadLetters.Tell(new DeadLetter(envelope.Message, envelope.Sender, receiver), envelope.Sender);
     }
 }

        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void Invoke(Envelope envelope)
        {
            var message = envelope.Message;
            CurrentMessage = message;
            _currentEnvelopeId ++;
            Sender = MatchSender(envelope);

            try
            {
                var autoReceivedMessage = message as IAutoReceivedMessage;
                if (autoReceivedMessage != null)
                    AutoReceiveMessage(envelope);
                else
                    ReceiveMessage(message);
                CurrentMessage = null;
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
            finally
            {
                CheckReceiveTimeout(); // Reschedule receive timeout
            }
        }

 /// <summary>
 /// Directly inject messages into actor receive behavior. Any exceptions
 /// thrown will be available to you, while still being able to use
 /// become/unbecome.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="sender">The sender.</param>
 public void Receive(object message, IActorRef sender = null)
 {
     var cell = Cell;
     sender = sender.IsNobody() ? cell.System.DeadLetters : sender;
     var envelope = new Envelope { Message = message, Sender = sender };
     cell.UseThreadContext(() => cell.ReceiveMessageForTest(envelope));
 }

 protected override bool LockedTryDequeue(out Envelope envelope)
 {
     if (_prioQueue.Count() > 0)
     {
         envelope = _prioQueue.Dequeue();
         return true;
     }
     envelope = default (Envelope);
     return false;
 }

        public void Enqueue(IActorRef receiver, Envelope envelope)
        {
            if (envelope.Message is DeadLetter)
            {
                // actor subscribing to DeadLetter. Drop it.
                return;
            }

            _deadLetters.Tell(new DeadLetter(envelope.Message, envelope.Sender, receiver), envelope.Sender);
        }

        /// <summary>
        /// Attempt to dequeue a message from the front of the prepend buffer.
        /// 
        /// If the prepend buffer is empty, dequeue a message from the normal
        /// <see cref="MessageQueue"/> wrapped but this wrapper.
        /// </summary>
        /// <param name="envelope">The message to return, if any</param>
        /// <returns><c>true</c> if a message was available, <c>false</c> otherwise.</returns>
        public bool TryDequeue(out Envelope envelope)
        {
            if (_prependBuffer.Count > 0)
            {
                envelope = _prependBuffer.Pop();
                return true;
            }

            return _messageQueue.TryDequeue(out envelope);
        }

        public override void SendMessage(Envelope envelope)
        {
            if(!(RouterConfig.IsManagementMessage(envelope.Message)) &&
                resizer.IsTimeForResize(_resizeCounter.GetAndIncrement()) &&
                _resizeInProgress.CompareAndSet(false, true))
            {
                base.SendMessage(new Envelope(new Resize(), Self, System));
            }

            base.SendMessage(envelope);
        }

  public void Enqueue(Envelope envelope)
  {
      if (PushTimeOut.Milliseconds >= 0)
      {
          _queue.TryAdd(envelope, PushTimeOut);
      }
      else
      {
          _queue.Add(envelope);
      }
 }

 public bool TryDequeue(out Envelope envelope)
 {
     Monitor.TryEnter(_lock, BlockTimeOut);
     try
     {
         return LockedTryDequeue(out envelope);
     }
     finally
     {
         Monitor.Exit(_lock);
     }
 }

 public void Enqueue(Envelope envelope)
 {
     Monitor.TryEnter(_lock, BlockTimeOut);
     try
     {
         LockedEnqueue(envelope);
     }
     finally
     {
         Monitor.Exit(_lock);
     }
 }

        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void Invoke(Envelope envelope)
        {
            CurrentMessage = envelope.Message;
            Sender = envelope.Sender;
            //set the current context

                try
                {
                    AutoReceiveMessage(envelope);
                }
                catch (Exception cause)
                {
                    Parent.Tell(new Failed(Self, cause));
                }

        }

        /*
 def autoReceiveMessage(msg: Envelope): Unit = {
    if (system.settings.DebugAutoReceive)
      publish(Debug(self.path.toString, clazz(actor), "received AutoReceiveMessage " + msg))

    msg.message match {
      case t: Terminated              ⇒ receivedTerminated(t)
      case AddressTerminated(address) ⇒ addressTerminated(address)
      case Kill                       ⇒ throw new ActorKilledException("Kill")
      case PoisonPill                 ⇒ self.stop()
      case sel: ActorSelectionMessage ⇒ receiveSelection(sel)
      case Identify(messageId)        ⇒ sender() ! ActorIdentity(messageId, Some(self))
    }
  }
         */

        protected virtual void AutoReceiveMessage(Envelope envelope)
        {
            var message = envelope.Message;

            var actor = _actor;
            var actorType = actor != null ? actor.GetType() : null;

            if (System.Settings.DebugAutoReceive)
                Publish(new Debug(Self.Path.ToString(), actorType, "received AutoReceiveMessage " + message));

            var m = envelope.Message;
            if (m is Terminated) ReceivedTerminated(m as Terminated);
            else if (m is AddressTerminated) AddressTerminated((m as AddressTerminated).Address);
            else if (m is Kill) Kill();
            else if (m is PoisonPill) HandlePoisonPill();
            else if (m is ActorSelectionMessage) ReceiveSelection(m as ActorSelectionMessage);
            else if (m is Identify) HandleIdentity(m as Identify);
        }

        /*
 def autoReceiveMessage(msg: Envelope): Unit = {
    if (system.settings.DebugAutoReceive)
      publish(Debug(self.path.toString, clazz(actor), "received AutoReceiveMessage " + msg))

    msg.message match {
      case t: Terminated              ⇒ receivedTerminated(t)
      case AddressTerminated(address) ⇒ addressTerminated(address)
      case Kill                       ⇒ throw new ActorKilledException("Kill")
      case PoisonPill                 ⇒ self.stop()
      case sel: ActorSelectionMessage ⇒ receiveSelection(sel)
      case Identify(messageId)        ⇒ sender() ! ActorIdentity(messageId, Some(self))
    }
  }
         */

        protected virtual void AutoReceiveMessage(Envelope envelope)
        {
            var message = envelope.Message;

            var actor = _actor;
            var actorType = actor != null ? actor.GetType() : null;

            if(System.Settings.DebugAutoReceive)
                Publish(new Debug(Self.Path.ToString(), actorType, "received AutoReceiveMessage " + message));

            envelope.Message
                .Match()
                .With<Terminated>(ReceivedTerminated)
                .With<AddressTerminated>(a => AddressTerminated(a.Address))
                .With<Kill>(Kill)
                .With<PoisonPill>(HandlePoisonPill)
                .With<ActorSelectionMessage>(ReceiveSelection)
                .With<Identify>(HandleIdentity);
        }

 public override void Post(IActorRef receiver, Envelope envelope)
 {
     var message = envelope.Message;
     if(message is ISystemMessage)
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded system message " + envelope+ " as a DeadLetter");
         _deadLetters.Tell(new DeadLetter(message, receiver, receiver), receiver);
     }
     else if(message is DeadLetter)
     {
         //Just drop it like it's hot
         Mailbox.DebugPrint("DeadLetterMailbox dropped DeadLetter " + envelope);
     }
     else
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded message " + envelope + " as a DeadLetter");
         var sender = envelope.Sender;
         _deadLetters.Tell(new DeadLetter(message, sender, receiver),sender);
     }
 }

 public override void Post(Envelope envelope)
 {
     var message = envelope.Message;
     if(message is SystemMessage)
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded system message " + envelope+ " as a DeadLetter");
         _deadLetters.Tell(new DeadLetter(message, _deadLetters, _deadLetters), _deadLetters);//TODO: When we have refactored Post to SystemEnqueue(ActorRef receiver, Envelope envelope), replace _deadLetters with receiver               
     }
     else if(message is DeadLetter)
     {
         //Just drop it like it's hot
         Mailbox.DebugPrint("DeadLetterMailbox dropped DeadLetter " + envelope);
     }
     else
     {
         Mailbox.DebugPrint("DeadLetterMailbox forwarded message " + envelope + " as a DeadLetter");
         var sender = envelope.Sender;
         _deadLetters.Tell(new DeadLetter(message,sender,_deadLetters),sender);//TODO: When we have refactored Post to Enqueue(ActorRef receiver, Envelope envelope), replace _deadLetters with receiver
     }
 }

        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        /// <exception cref="ActorKilledException">
        /// This exception is thrown if a <see cref="Akka.Actor.Kill"/> message is included in the given <paramref name="envelope"/>.
        /// </exception>>
        public void Invoke(Envelope envelope)
        {
            
            var message = envelope.Message;
            var influenceReceiveTimeout = !(message is INotInfluenceReceiveTimeout);

            try
            {
                // Akka JVM doesn't have these lines
                CurrentMessage = envelope.Message;
                _currentEnvelopeId++;

                Sender = MatchSender(envelope);

                if (influenceReceiveTimeout)
                {
                    CancelReceiveTimeout();
                }

                if (message is IAutoReceivedMessage)
                {
                    AutoReceiveMessage(envelope);
                }
                else
                {
                    ReceiveMessage(message);
                }
                CurrentMessage = null;
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
            finally
            {
                if (influenceReceiveTimeout)
                {
                    CheckReceiveTimeout(); // Reschedule receive timeout
                }
            }
        }

        /// <summary>
        ///     Invokes the specified envelope.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void Invoke(Envelope envelope)
        {
            var message = envelope.Message;
            CurrentMessage = message;
            Sender = envelope.Sender;

            try
            {
                var autoReceivedMessage = message as AutoReceivedMessage;
                if(autoReceivedMessage!=null)
                    AutoReceiveMessage(envelope);
                else
                    ReceiveMessage(message);
            }
            catch(Exception cause)
            {
                Mailbox.Suspend();
                Parent.Tell(new Failed(Self, cause));
            }

        }

 protected override void LockedEnqueue(Envelope envelope)
 {
     _prioQueue.Enqueue(envelope);
 }

        /// <summary>
        ///     Systems the invoke.
        /// </summary>
        /// <param name="envelope">The envelope.</param>
        public void SystemInvoke(Envelope envelope)
        {

            try
            {
                var m = envelope.Message;

                if (m is CompleteTask) HandleCompleteTask(m as CompleteTask);
                else if (m is Failed) HandleFailed(m as Failed);
                else if (m is DeathWatchNotification)
                {
                    var msg = m as DeathWatchNotification;
                    WatchedActorTerminated(msg.Actor, msg.ExistenceConfirmed, msg.AddressTerminated);
                }
                else if (m is Create) HandleCreate((m as Create).Failure);
                else if (m is Watch)
                {
                    var watch = m as Watch;
                    AddWatcher(watch.Watchee, watch.Watcher);
                }
                else if (m is Unwatch)
                {
                    var unwatch = m as Unwatch;
                    RemWatcher(unwatch.Watchee, unwatch.Watcher);
                }
                else if (m is Recreate) FaultRecreate((m as Recreate).Cause);
                else if (m is Suspend) FaultSuspend();
                else if (m is Resume) FaultResume((m as Resume).CausedByFailure);
                else if (m is Terminate) Terminate();
                else if (m is Supervise)
                {
                    var supervise = m as Supervise;
                    Supervise(supervise.Child, supervise.Async);
                }
                else
                {
                    throw new NotSupportedException("Unknown message " + m.GetType().Name);
                }
            }
            catch (Exception cause)
            {
                HandleInvokeFailure(cause);
            }
        }

 /// <summary>
 /// If the envelope.Sender property is null, then we'll substitute
 /// Deadletters as the <see cref="Sender"/> of this message.
 /// </summary>
 /// <param name="envelope">The envelope we received</param>
 /// <returns>An IActorRef that corresponds to a Sender</returns>
 private IActorRef MatchSender(Envelope envelope)
 {
     var sender = envelope.Sender;
     return sender ?? System.DeadLetters;
 }