public static void SendMessage(byte[] address, byte[] message, ZmqSocket socket)
 {
     ZmqMessage zmqMessage = new ZmqMessage();
     zmqMessage.Append(new Frame(address));
     zmqMessage.Append(new Frame(message));
     socket.SendMessage(zmqMessage);
 }

        public static void SendRequest(Int32 request,ref ZmqSocket socket)
        {
            //ZmqSocket socket;
            try
            {
                //socket = CreateSocket();

                var message = new ZmqMessage();
                message.Append(Encoding.UTF8.GetBytes(String.Format(" Hello {0}.", request)));

                socket.SendMessage(message);

                // TODO: add receive timeout as param
                var dataResult = socket.ReceiveMessage();

                Console.WriteLine(Encoding.UTF8.GetString(dataResult[0]));
                Console.WriteLine(Encoding.UTF8.GetString(dataResult[1]));

            }
            catch (Exception ex)
            {
                socket.Close();
                socket = CreateSocket();
                Console.WriteLine(ex.ToString());
            }
        }

        public Service1(ZmqSocket socket)
        {
            _timer.Interval = 3000;
            _socket = socket;

            InitializeComponent();
        }

        private void RecieverPollInHandler(ZmqSocket reciever, ZmqSocket sender)
        {
            Thread.Sleep(100);
            var fileToMeasure = reciever.Receive(Encoding.Unicode);

            Int64 fileLength = 0;
            FileStream fs = null;

            try
            {
                fs = File.OpenRead(fileToMeasure);
                fileLength = fs.Length;
            }
            catch (IOException)
            {
            }
            finally
            {
                if (fs != null) fs.Dispose();
            }

            Console.Write(".");

            sender.Send(fileLength.ToString(), Encoding.Unicode);
        }

        public static KvMsg Receive(ZmqSocket subscriber)
        {
            var key = subscriber.Receive(Encoding.Unicode);
            var sequence = BitConverter.ToInt64(Encoding.Unicode.GetBytes(subscriber.Receive(Encoding.Unicode)), 0);
            var body = subscriber.Receive(Encoding.Unicode);

            return new KvMsg(sequence, key, body);
        }

        public void Send(ZmqSocket socket)
        {
            for (int index = frames.Count - 1; index > 0; index--)
            {
                socket.SendMore(frames[index]);
            }

            socket.Send(frames[0]);
        }

        public void Receive(ZmqSocket ZmqSocket)
        {
            var zmqMessage = ZmqSocket.ReceiveMessage();

            foreach (var frame in zmqMessage)
            {
                frames.Insert(0, frame.Buffer);
            }
        }

        internal SocketEventArgs(ZmqSocket socket, PollEvents readyEvents)
        {
            if (socket == null)
            {
                throw new ArgumentNullException("socket");
            }

            this.Socket = socket;
            this.ReceiveReady = readyEvents.HasFlag(PollEvents.PollIn);
            this.SendReady = readyEvents.HasFlag(PollEvents.PollOut);
        }

        public override void Bind(ZmqSocket socket, ZeroRoute config)
        {
            ZeroLog.LogInfo("push bind....");

            foreach (var endPoint in config.ConnectEndPoints())
            {
                socket.Connect(endPoint);

                ZeroLog.LogInfo("push bind....");
            }
        }

        private static void ReceiverPollInHandler(ZmqSocket receiver, ZmqSocket sender)
        {
            string task = receiver.Receive(Encoding.Unicode);

            //  Simple progress indicator for the viewer;
            Console.WriteLine("{0}.", task);

            int sleepTime = Convert.ToInt32(task);
            Thread.Sleep(sleepTime);

            // Send 'result' to the sink
            sender.Send("", Encoding.Unicode);
        }

        protected override OpStatus OnSendComplete(ZmqSocket Socket)
        {
            // Request-replay socket (REQ) should immideatly receive message just after 'send'
#if DEBUG
            System.Console.WriteLine("[RequestReplaySocket] Before receiveng the package");
            System.Console.WriteLine("[RequestReplaySocket] Current thread ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
#endif

            ZmqMessage okMessage = Socket.ReceiveMessage(TimeSpan.FromSeconds(1));

#if DEBUG
            System.Console.WriteLine("[RequestReplaySocket] Replay message was received. Status is: " + Socket.ReceiveStatus.ToString());
#endif
            return Socket.ReceiveStatus.Convert();
        }

        /// <summary>
        /// Add a socket that will be polled for input/output events, depending on its capabilities.
        /// </summary>
        /// <param name="socket">The <see cref="ZmqSocket"/> to poll.</param>
        /// <exception cref="ArgumentNullException"><paramref name="socket"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="socket"/> has no event handlers.</exception>
        public void AddSocket(ZmqSocket socket)
        {
            if (socket == null)
            {
                throw new ArgumentNullException("socket");
            }

            var pollEvents = socket.GetPollEvents();

            if (pollEvents == PollEvents.None)
            {
                throw new ArgumentOutOfRangeException("socket", "Unable to add socket without at least one handler.");
            }

            _pollableSockets.Add(new PollItem(socket.SocketHandle, pollEvents), socket);
        }

 internal ZmqMessageSender(Uri serviceUri)
 {
     context = ZmqContext.Create();
     socket = context.CreateSocket(SocketType.REQ);
     var address = string.Format("tcp://{0}:{1}", serviceUri.Host, serviceUri.Port);
     socket.Connect(address);
 }

 public ClientForm()
 {
     InitializeComponent();
     context = ZmqContext.Create();
     client = context.CreateSocket(SocketType.REQ);
     client.Connect("tcp://localhost:5555");
 }

 public ZmqPublisher(string endpoint)
 {
     _endpoint = endpoint;
     _context = ZmqContext.Create();
     _socket = _context.CreateSocket(SocketType.PUB);
     _socket.Bind(_endpoint);
 }

 public void InitialiseSocket()
 {
     m_PublishSocket = m_Context.CreateSocket(SocketType.PUB);
     m_PublishSocket.Bind("epgm://239.1.1.1:9500");
     m_PublishSocket.Bind("tcp://*:9500");
     m_PublishSocket.Bind("inproc://Local");
 }

        public Subscriber(string _guid, string _targetGuid, string _host, int _port, ZmqContext _ctx)
        {
            guid = _guid;
            targetGuid = _targetGuid;
            host = _host;
            port = _port;
            if (port > 0)
                connectionString = String.Format("tcp://{0}:{1}", host, port);
            else
                connectionString = String.Format("inproc://{0}", targetGuid.ToLower());
            buf = new byte[1024 * 1024];
            subscribeChannels = new List<string>();

            if (_ctx == null)
            {
                shardedCtx = false;
                ctx = ZmqContext.Create();
            }
            else
            {
                shardedCtx = true;
                ctx = _ctx;
            }
            socket = ctx.CreateSocket(SocketType.SUB);
            if (log.IsDebugEnabled) log.DebugFormat("Subscriber connecting to: `{0}`", connectionString);
            socket.Subscribe(Proxy.StringToByteArray(guid));
            socket.Connect(connectionString);
            socket.ReceiveHighWatermark = 1000000;
            socket.ReceiveBufferSize = 128 * 1024;

            lastActiveTime = Proxy.Unixtimestamp();
            log.InfoFormat("Connected successfuly to: `{0}` `{1}`", connectionString, targetGuid);
        }

        private static void Open(Object cancelationToken)
        {
            context = ZmqContext.Create();

            frontend = context.CreateSocket(SocketType.ROUTER);
            backend = context.CreateSocket(SocketType.DEALER);
            backend.Identity = Encoding.UTF8.GetBytes("inproc://workers");
            frontend.Bind("tcp://127.0.0.1:5000");

            backend.Bind("inproc://workers");

            workerThreads = new Thread[2];
            for (int threadId = 0; threadId < workerThreads.Length; threadId++)
            {
                workerThreads[threadId] = new Thread(WorkerRoutine);
                workerThreads[threadId].Start(context);
            }

            frontend.ReceiveReady += new EventHandler<SocketEventArgs>(frontend_ReceiveReady);
            backend.ReceiveReady += new EventHandler<SocketEventArgs>(backend_ReceiveReady);

            Poller poller = new Poller(new[] { frontend, backend });
            var token = (CancellationToken)cancelationToken;
            while (!token.IsCancellationRequested)
            {
                poller.Poll(TimeSpan.FromMilliseconds(100));
            }
        }

		public ZeroMqMessagePublisher(ZmqContext context)
		{
			Console.WriteLine("Hey there");
			_pub = context.CreateSocket(SocketType.PUB);
			_pub.Bind("tcp://*:5555");

			Console.WriteLine("Hello");
		}

 public void CreateCommandReceiverSocket(string endpoint)
 {
     _receptionSocket = _context.CreateSocket(SocketType.PULL);
     _receptionSocket.Linger = TimeSpan.FromSeconds(1);
     _receptionSocket.ReceiveHighWatermark = 30000;
     _receptionSocket.Bind(endpoint);
     _logger.DebugFormat("Command processor socket bound to {0}", endpoint);
 }