public HandlerMapping(string version, string command, IMessageHandler handler)
        {
            if (version == null)
            {
                throw new ArgumentNullException("version");
            }

            if (command == null)
            {
                throw new ArgumentNullException("command");
            }

            if (handler == null)
            {
                throw new ArgumentNullException("handler");
            }

            _catchAll = version == "*";
            _version = _catchAll ? 
            	new string[0] : 
            	#if CF
            	version.Split(new[] { ',' })
            	#else
            	version.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
            	#endif
            	;
            _command = command;
            _handler = handler;
        }

        public PriorityBurrowConsumer(IModel channel, IMessageHandler messageHandler, IRabbitWatcher watcher, bool autoAck, int batchSize)
            : base(channel)
        {
            if (channel == null)
            {
                throw new ArgumentNullException("channel");
            }
            if (messageHandler == null)
            {
                throw new ArgumentNullException("messageHandler");
            }
            if (watcher == null)
            {
                throw new ArgumentNullException("watcher");
            }

            if (batchSize < 1)
            {
                throw new ArgumentException("batchSize must be greater than or equal 1", "batchSize");
            }

            Model.ModelShutdown += WhenChannelShutdown;
            Model.BasicRecoverAsync(true);

            _messageHandler = messageHandler;
            _messageHandler.HandlingComplete += MessageHandlerHandlingComplete;
            _watcher = watcher;
            _autoAck = autoAck;
            _batchSize = batchSize;
        }

        public static void RegisterHandler(Type type, IMessageHandler handlerObject)
        {
            lock (syncObj)
            {
                if (handlers.ContainsKey(type))
                {
                    //Console.WriteLine("Type found - checking handlers list");
                    LinkedList<IMessageHandler> typeHandlers = handlers[type];
                    if (typeHandlers == null) // для этого типа раньше не регистрировались подписчики
                    {
                        typeHandlers = new LinkedList<IMessageHandler>();
                    }

                    // WARNING: linear search
                    if (!typeHandlers.Contains(handlerObject)) // для этого типа и этого объекта не назначен этот же объект-обработчик
                        typeHandlers.AddLast(handlerObject);
                }
                else
                {
                    //Console.WriteLine("Type not found - creating handlers list");
                    handlers.Add(type, new LinkedList<IMessageHandler>());
                    handlers[type].AddLast(handlerObject);
                }
            }
        }

        /// <summary>
        /// Creates this controller
        /// </summary>
        /// <param name="user">Command user that this controller listens to</param>
        /// <param name="actionTarget">Entity actions are sent to this object</param>
        public UserRtsController( CommandUser user, IMessageHandler actionTarget )
        {
            m_Target = actionTarget;

            CommandList entityCommandList = CommandListManager.Instance.FindOrCreateFromEnum( typeof( EntityCommands ) );
            user.AddActiveListener( entityCommandList, OnCommandActive );
        }

        public override void Invoke(Type msgType, IMessage message, IMessageHandler handler)
        {
            // PERF: cache or create compiled Lambda to invoke this
            var method = handler.GetType().GetMethod("Handle", new[] { msgType });

            method.Invoke(handler, new object[] { message });
        }

        public NotificationConsumer(IMessageHandler messageHandler, IChannelWrapper channelWrapper)
        {
            _messageHandler = messageHandler;
            _channelWrapper = channelWrapper;

            Listen();
        }

 public BlockUserTask(IMessageHandler consumeHandler, IMessageHandler publishHandler, string publishRoutingKey, IFeedBackDataManager feedBackManager, IAccountManager accountManager, IBlackListDataManager blackListDataManager)
     : base(consumeHandler, publishHandler, publishRoutingKey)
 {
     _feedBackManager = feedBackManager;
     _accountManager = accountManager;
     _blackListDataManager = blackListDataManager;
 }

 public PollingConsumer(IPollableChannel inputChannel, IMessageHandler handler)
 {
     AssertUtils.ArgumentNotNull(inputChannel, "inputChannel");
     AssertUtils.ArgumentNotNull(handler, "handler");
     _inputChannel = inputChannel;
     _handler = handler;
 }

 public MessageClient(IFramedClient framedClient, 
                      IStacksSerializer packetSerializer,
                      IMessageHandler messageHandler)
     : this(new MessageIdCache(),
            framedClient, packetSerializer, messageHandler)
 {
 }

 public Eve(IMessageHandler messager)
 {
     pMessager = messager;
     pTimeOut.AutoReset = false;
     pTimeOut.Interval = pCommonTimeout;
     pTimeOut.Elapsed += PTimeOutElapsed;
 }

 public PipedRoute(IMessageHandler handler, MethodInfo endpoint, string commandName, string[] parameterNames)
 {
     _commandName = commandName;
     _parameterNames = parameterNames;
     Handler = handler;
     EndPoint = endpoint;
 }

 public RedisMessageHandlerWorker(
     IRedisClientsManager clientsManager, IMessageHandler messageHandler, string queueName,
     Action<IMessageHandlerBackgroundWorker, Exception> errorHandler)
     : base(messageHandler, queueName, errorHandler)
 {
     this.clientsManager = clientsManager;
 }

 public EventDrivenConsumer(ISubscribableChannel inputChannel, IMessageHandler handler)
 {
     AssertUtils.ArgumentNotNull(inputChannel, "inputChannel must not be null");
     AssertUtils.ArgumentNotNull(handler, "handler must not be null");
     _inputChannel = inputChannel;
     _handler = handler;
 }

        //        1. List<pos + DateTime (class)> // högre och högre tid på olika pos
        //        2. bild i ps, rita cirklar dra streck mellan dom..
        //        3. bygga på med vinklar (sist, till att börja med kör vi med position)
        public override void Initialize(GameContext context)
        {
            base.Initialize(context);

            snapShots = new List<Snapshot>();
            snapShots.Add(new Snapshot(TimeSpan.FromSeconds(0), new Vector2(487.0f, 585.0f)));
            snapShots.Add(new Snapshot(TimeSpan.FromSeconds(3), new Vector2(510.0f, 200.0f)));
            snapShots.Add(new Snapshot(TimeSpan.FromSeconds(7), new Vector2(775.0f, 326.0f)));
            snapShots.Add(new Snapshot(TimeSpan.FromSeconds(10), new Vector2(1142.0f, 103.0f)));

            this.spriteBatch = spriteBatch ?? new SpriteBatch(Context.Graphics.Device);

            time = "";
            interpolate = new Vector2();

            gameServer = ServiceLocator.Get<IGameServer>();
            gameClient = ServiceLocator.Get<IGameClient>();
            messageHandler = ServiceLocator.Get<IMessageHandler>();

            // Create the connection between the client and server
            gameServer.Start();
            gameClient.Connect();

            //sendTimer = new GameTimer(TimeSpan.FromMilliseconds(1000 / 20), SendClientSpatial);

            Context.Input.Keyboard.ClearMappings();
            Context.Input.Keyboard.AddMapping(Keys.F1);
            Context.Input.Keyboard.AddMapping(Keys.F2);
            Context.Input.Keyboard.AddMapping(Keys.F3);
        }

 protected MessageItemProcessor(IMessageHandler consumeHandler, IMessageHandler publishHandler,
                                string publishRoutingKey)
 {
     ConsumeHandler = consumeHandler;
     PublishHandler = publishHandler;
     IsActive = true;
     PublishRoutingKey = publishRoutingKey;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MessageProcessingContext"/> class.
        /// </summary>
        /// <param name="message">The Message.</param>
        /// <param name="handler">The handler.</param>
        public MessageProcessingContext(IMessage message, IMessageHandler handler)
        {
            Contract.Requires(message != null);
            Contract.Requires(handler != null);

            this.Message = message;
            this.Handler = handler;
        }

 /// <summary>
 /// Initialize an object of <see cref="BurrowConsumer"/>
 /// </summary>
 /// <param name="channel">RabbitMQ.Client channel</param>
 /// <param name="messageHandler">An instance of message handler to handle the message from queue</param>
 /// <param name="watcher"></param>
 /// <param name="autoAck">If set to true, the msg will be acked after processed</param>
 /// <param name="batchSize"></param>
 public BurrowConsumer(IModel channel,
                       IMessageHandler messageHandler,
                       IRabbitWatcher watcher,
                       bool autoAck,
                       int batchSize) : this(channel, messageHandler, watcher, autoAck, batchSize, true)
 {
     // This is the public constructor to start the consuming thread straight away
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="QueueCreationDecorator" /> class.
 /// </summary>
 /// <param name="metrics">The metrics factory.</param>
 /// <param name="handler">The handler.</param>
 /// <param name="connectionInformation">The connection information.</param>
 public MessageHandlerDecorator(IMetrics metrics,
     IMessageHandler handler,
     IConnectionInformation connectionInformation)
 {
     var name = handler.GetType().Name;
     _runCodeTimer = metrics.Timer($"{connectionInformation.QueueName}.{name}.HandleTimer", Units.Calls);
     _handler = handler;
 }

 public MessageHandlerWorker(
     IRedisClientsManager clientsManager, IMessageHandler messageHandler, string queueName,
     Action<MessageHandlerWorker, Exception> errorHandler)
 {
     this.clientsManager = clientsManager;
     this.messageHandler = messageHandler;
     this.QueueName = queueName;
     this.errorHandler = errorHandler;
 }

 /// <summary>
 /// Initializes a new <see cref="HandlingRule"/> with the supplied message
 /// <paramref name="specification"/>, <see cref="MessageHandler"/>, and
 /// <paramref name="queueName"/>.
 /// </summary>
 /// <param name="specification">The message specification that selects messages 
 /// to which the handling rule applies</param>
 /// <param name="messageHandler">The handler to which messages matching the
 /// specification will be routed</param>
 /// <param name="queueName">(Optional) The name of the queue in which matching
 /// messages will be placed while they await handling</param>
 /// <remarks>
 /// If the <paramref name="queueName"/> is ommitted, a default queue name will
 /// be generated based on the MD5 hash of the full type name of the supplied
 /// <paramref name="messageHandler"/>
 /// </remarks>
 /// <seealso cref="GenerateQueueName"/>
 public HandlingRule(IMessageSpecification specification, IMessageHandler messageHandler,
     QueueName queueName = null)
 {
     if (specification == null) throw new ArgumentNullException("specification");
     if (messageHandler == null) throw new ArgumentNullException("messageHandler");
     _specification = specification;
     _messageHandler = messageHandler;
     _queueName = queueName ?? GenerateQueueName(messageHandler);
 }