public bool Connect()
        {
            var tmp = Handshake.Host.Split(':');
            var port = 81;
            var host = Handshake.Host;
            if (tmp.Length > 1)
            {
                port = Int32.Parse(tmp[1]);
                host = tmp[0];
            }

            Socket.ReceiveBufferSize = 1024 * 64;
            Socket.Connect(host, port);
            SendHandshake();
            VersionDataFrame = null;

            if (!ReadHandshake())
            {
                Socket.Close();
                return false;
            }

            if (VersionDataFrame == null)
                Receive(VersionDataFrame);

            return true;
        }
        public string Receive(DataFrame frame = null)
        {
            if (frame == null)
                frame = new DataFrame();

            var buffer = new byte[1024 * 8];

            int sizeOfReceivedData =  Socket.Receive(buffer);
            frame.Append(buffer);
            if (frame.IsComplete)
                return frame.ToString();
            else
                return Receive(frame);
        }
        private bool ReadHandshake()
        {
            var hs = new byte[1024];
            int count = Socket.Receive(hs);

            // check that "version" DataFrame has included in this handshake data (DataFrame start with 0 and end with 255)
            int start = 0;
            int end = count - 1;
            int dataFrameLength = 0;
            if (hs[end] == 255)
            {
                // find "version" DataFrame length
                for (int i = end; i >= start; --i)
                {
                    if (hs[i] == 0)
                    {
                        dataFrameLength = end - i + 1;
                        break;
                    }
                }
            }

            // make version DataFrame
            if (dataFrameLength != 0)
            {
                var versionByte = new byte[dataFrameLength];
                Array.Copy(hs, count - dataFrameLength, versionByte, 0, dataFrameLength);
                VersionDataFrame = new DataFrame();
                VersionDataFrame.Append(versionByte);
            }

            var bytes = new ArraySegment<byte>(hs, 0, count - dataFrameLength);

            ServerHandshake handshake = null;
            if (bytes.Count > 0)
            {
                handshake = ParseServerHandshake(bytes);
            }

            var isValid = (handshake != null) &&
                        (handshake.Origin == Handshake.Origin) &&
                        (handshake.Location == "ws://" + Handshake.Host + Handshake.ResourcePath);

            // skip checking handshake.AnswerBytes against Handshake.ExpectedAnswer
            /*if (isValid)
            {
                for (int i = 0; i < 16; i++)
                {
                    if (handshake.AnswerBytes[i] != Handshake.ExpectedAnswer[i])
                    {
                        isValid = false;
                        break;
                    }

                }
            }*/

            return isValid;
        }