protected override byte[] SerializeMessage(IScsMessage message)
        {
            var bytes = base.SerializeMessage(message);
            if (compress) bytes = CompressionManager.CompressGZip(bytes);
            if (encrypt) bytes = XXTEA.Encrypt(bytes, keys);

            return bytes;
        }

        public byte[] GetBytes(IScsMessage message)
        {
            //Serialize the message to a byte array
            byte[] bytes = message is ScsTextMessage ? 
                Encoding.Default.GetBytes(((ScsTextMessage)message).Text) :
                ((ScsRawDataMessage)message).MessageData;

            return bytes;
        }

 public byte[] GetBytes(IScsMessage message)
 {
     try
     {
         Cmd cmd = message as Cmd;
         return _packer.pack(cmd).ToArray();
     }
     catch
     {
         return null;
     }
 }

 public byte[] GetBytes(IScsMessage message)
 {
     var m = message as Protocols.GpsMessage;
     List<byte> bytes = new List<byte>();
     logger.Debug("Data {0}", BitConverter.ToString(m.Data));
     if (m.Data != null)
     {
         bytes.Add(0x02);
         bytes.Add(m.Data[m.Data.Length - 2]);
         bytes.Add(m.Data[m.Data.Length - 1]);
         m.Data = bytes.ToArray();
     }
     return bytes.ToArray();
 }

 public void SendMessage(IPEndPoint remote, IScsMessage msg)
 {
     try
     {
         byte[] buffer = this.WireProtocol.GetBytes(msg);
         if (buffer != null)
             _udp_peer.SendData(buffer, remote);
     }
     catch (System.Exception ex)
     {
         EzLogger.GlobalLogger.warning(string.Format("{0}{2}{1}{2}",
             ex.Message, ex.StackTrace, Environment.NewLine));
     }
 }

 /// <summary>
 /// Serializes a message to a byte array to send to remote application.
 ///             This method is synchronized. So, only one thread can call it concurrently.
 /// 
 /// </summary>
 /// <param name="message">Message to be serialized</param><exception cref="T:Tera.NetworkApi.Communication.Scs.Communication.CommunicationException">Throws CommunicationException if message is bigger than maximum allowed message length.</exception>
 public byte[] GetBytes(IScsMessage message)
 {
     byte[] numArray = this.SerializeMessage(message);
     int length = numArray.Length;
     if (length > 134217728)
     {
         throw new CommunicationException("Message is too big (" + (object)length + " bytes). Max allowed length is " + (string)(object)134217728 + " bytes.");
     }
     else
     {
         byte[] buffer = new byte[length + 4];
         BinarySerializationProtocol.WriteInt32(buffer, 0, length);
         Array.Copy((Array)numArray, 0, (Array)buffer, 4, length);
         return buffer;
     }
 }

        /// <summary>
        /// The sender of a message needs to provide a means to convert a (high-level) object into raw bytes
        /// that will be sent over the network connection.
        /// </summary>
        protected override byte[] SerializeMessage(IScsMessage message)
        {
            if (message is ScsRawDataMessage)
            {
                return (((ScsRawDataMessage)message).MessageData);
            }

            if (message is ScsTextMessage)
            {
                return Encoding.UTF8.GetBytes(((ScsTextMessage)message).Text);
            }

            if (message is ScsPingMessage)
            {
                //if the application idles, occasional ScsPingMessage(s) are being sent out
                //trying to serialize this as ScsTextMessage will throw an exception
            }

            return null;
        }

        /// <summary>
        /// Serializes a message to a byte array to send to remote application.
        /// This method is synchronized. So, only one thread can call it concurrently.
        /// </summary>
        /// <param name="message">Message to be serialized</param>
        /// <exception cref="CommunicationException">Throws CommunicationException if message is bigger than maximum allowed message length.</exception>
        public byte[] GetBytes(IScsMessage message)
        {
            //Serialize the message to a byte array
            var serializedMessage = SerializeMessage(message); 
           
            //Check for message length
            var messageLength = serializedMessage.Length;
            if (messageLength > MaxMessageLength)
            {
                throw new CommunicationException("Message is too big (" + messageLength + " bytes). Max allowed length is " + MaxMessageLength + " bytes.");
            }

            //Create a byte array including the length of the message (4 bytes) and serialized message content
            var bytes = new byte[messageLength + 4];
            WriteInt32(bytes, 0, messageLength);
            Array.Copy(serializedMessage, 0, bytes, 4, messageLength);

            //Return serialized message by this protocol
            return bytes;
        }

        /// <summary>
        /// Send a Message and Wati for Reply
        /// </summary>
        /// <typeparam name="T">The expected Value</typeparam>
        /// <param name="msg">the message to send</param>
        /// <returns></returns>
        public static Task<IScsMessage> SendMessageWithReplyAsync(this IScsClient client, IScsMessage msg)
        {
            TaskCompletionSource<IScsMessage> tcs = new TaskCompletionSource<IScsMessage>();

            using (var requestReplyMessenger = new RequestReplyMessenger<IScsClient>(client))
            {
                requestReplyMessenger.Start(); //Start request/reply messenger

                //Send user message to the server and get response
                try {
                    var response = requestReplyMessenger.SendMessageAndWaitForResponse(msg);
                    tcs.SetResult(response);
                }
                catch (Exception ex)
                {
                    tcs.SetException(ex);
                }
            }

            return tcs.Task;
        }

        protected virtual void OnMessageReceived(IPEndPoint remote, IScsMessage msg)
        {
            EzLogger.GlobalLogger.debug(string.Format("udp message from {0}: {1}", remote, msg));

            if (MessageReceived != null)
            {
                MessageReceived(remote, new MessageEventArgs(msg));
            }
        }

 /// <summary>
 /// Raises MessageReceived event.
 /// 
 /// </summary>
 /// <param name="message">Received message</param>
 private void OnMessageReceived(IScsMessage message)
 {
     EventHandler<MessageEventArgs> eventHandler = this.MessageReceived;
     if (eventHandler == null)
         return;
     eventHandler((object)this, new MessageEventArgs(message));
 }

 /// <summary>
 /// Sends a message to the client.
 /// 
 /// </summary>
 /// <param name="message">Message to be sent</param>
 public void SendMessage(IScsMessage message)
 {
     this._communicationChannel.SendMessage(message);
 }

 public byte[] GetBytes(IScsMessage message)
 {
     return ((SendPacket) message).Data;
 }

        /// <summary>
        /// Sends a message to the server.
        /// </summary>
        /// <param name="message">Message to be sent</param>
        /// <exception cref="CommunicationStateException">Throws a CommunicationStateException if client is not connected to the server.</exception>
        public void SendMessage(IScsMessage message)
        {
            if (CommunicationState != CommunicationStates.Connected)
            {
                throw new CommunicationStateException("Client is not connected to the server.");
            }

            _communicationChannel.SendMessage(message);
        }

        /// <summary>
        /// Sends a message to the remote application.
        /// </summary>
        /// <param name="message">Message to be sent</param>
        protected override void SendMessageInternal(IScsMessage message)
        {
            //Send message
            var totalSent = 0;
            lock (_syncLock)
            {
                //Create a byte array from message according to current protocol
                var messageBytes = WireProtocol.GetBytes(message);
                //Send all bytes to the remote application
                while (totalSent < messageBytes.Length)
                {
                    var sent = _clientSocket.Send(messageBytes, totalSent, messageBytes.Length - totalSent, SocketFlags.None);
                    if (sent <= 0)
                    {
                        throw new CommunicationException("Message could not be sent via TCP socket. Only " + totalSent + " bytes of " + messageBytes.Length + " bytes are sent.");
                    }

                    totalSent += sent;
                }

                LastSentMessageTime = DateTime.Now;
                OnMessageSent(message);
            }
        }

 /// <summary>
 /// Sends a message to the remote application.
 /// 
 /// </summary>
 /// <param name="message">Message to be sent</param>
 protected override void SendMessageInternal(IScsMessage message)
 {
     int offset = 0;
     lock (this._syncLock)
     {
         byte[] local_1 = this.WireProtocol.GetBytes(message);
         while (offset < local_1.Length)
         {
             int local_2 = this._clientSocket.Send(local_1, offset, local_1.Length - offset, SocketFlags.None);
             if (local_2 <= 0)
                 throw new CommunicationException("Message could not be sent via TCP socket. Only " + (object)offset + " bytes of " + (string)(object)local_1.Length + " bytes are sent.");
             else
                 offset += local_2;
         }
         this.LastSentMessageTime = DateTime.Now;
         this.OnMessageSent(message);
     }
 }

 /// <summary>
 /// Creates a new MessageEventArgs object.
 /// </summary>
 /// <param name="message">Message object that is associated with this event</param>
 public MessageEventArgs(IScsMessage message, DateTime receivedTimestamp)
 {
     Message = message;
     ReceivedTimestamp = receivedTimestamp;
 }

 public byte[] GetBytes(IScsMessage message)
 {
     Session.Encrypt(ref ((GameMessage) message).Data);
     return ((GameMessage) message).Data;
 }

 public byte[] GetBytes(IScsMessage message)
 {
     return ((OuterNetworkMessage)message).Data;
 }

        /// <summary>
        /// Sends a message to the remote application.
        /// </summary>
        /// <param name="message">Message to be sent</param>
        protected override void SendMessageInternal(IScsMessage message)
        {
            //Send message
            var totalSent = 0;
            lock (_syncLock)
            {
                //Create a byte array from message according to current protocol
                var messageBytes = WireProtocol.GetBytes(message);
                //Send all bytes to the remote application
                while (totalSent < messageBytes.Length)
                {
                    try
                    {
                        var sent = _clientSocket.Send(messageBytes, totalSent, messageBytes.Length - totalSent, SocketFlags.None);
                        if (sent <= 0)
                        {
                            throw new CommunicationException("Message could not be sent via TCP socket. Only " + totalSent + " bytes of " + messageBytes.Length + " bytes are sent.");
                        }

                        totalSent += sent;
                    }
                    catch (SocketException ex)
                    {
                        if (ex.SocketErrorCode == SocketError.WouldBlock ||
                            ex.SocketErrorCode == SocketError.IOPending ||
                            ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
                        {
                            // socket buffer is probably full, wait and try again
                            Thread.Sleep(30);
                        }
                    }
                }

                LastSentMessageTime = DateTime.Now;

                OnMessageSent(message);
            }
        }