public byte[] FromBytes(byte[] data)
        {
            int dataBegin = 2;
            var nibble2   = (byte)(data[0] & 0x0F);
            var nibble1   = (byte)(data[0] & 0xF0);

            if ((nibble1 & EndBit) == EndBit)
            {
                IsEnd = true;
            }


            //Combine bytes to form one large number
            PayloadSize = (byte)(data[1] & 0x7F);

            switch (PayloadSize)
            {
            case 126:
                Array.Reverse(data, dataBegin, 2);
                PayloadSize = BitConverter.ToUInt16(data, dataBegin);
                dataBegin  += 2;
                break;

            case 127:
                Array.Reverse(data, dataBegin, 8);
                PayloadSize = BitConverter.ToUInt64(data, dataBegin);
                dataBegin  += 8;
                break;
            }

            PayloadSizeRemaining = PayloadSize;
            IsMasked             = Convert.ToBoolean((data[1] & 0x80) >> 7);
            Mask             = 0;
            CurrentMaskIndex = 0;

            if (IsMasked)
            {
                Mask       = BitConverter.ToInt32(data, dataBegin);
                dataBegin += 4;
            }

            OpCode = (DataFrame.OpCode)nibble2;
            var someBytes = new byte[dataBegin];

            Array.Copy(data, 0, someBytes, 0, dataBegin);
            return(someBytes);
        }
        public byte[] FromBytes(byte[] data)
        {
            int dataBegin = 2;
            var nibble2 = (byte) (data[0] & 0x0F);
            var nibble1 = (byte) (data[0] & 0xF0);

            if ((nibble1 & EndBit) == EndBit)
            {
                IsEnd = true;
            }


            //Combine bytes to form one large number
            PayloadSize = (byte) (data[1] & 0x7F);

            switch (PayloadSize)
            {
                case 126:
                    Array.Reverse(data, dataBegin, 2);
                    PayloadSize = BitConverter.ToUInt16(data, dataBegin);
                    dataBegin += 2;
                    break;
                case 127:
                    Array.Reverse(data, dataBegin, 8);
                    PayloadSize = BitConverter.ToUInt64(data, dataBegin);
                    dataBegin += 8;
                    break;
            }

            PayloadSizeRemaining = PayloadSize;
            IsMasked = Convert.ToBoolean((data[1] & 0x80) >> 7);
            Mask = 0;
            CurrentMaskIndex = 0;

            if (IsMasked)
            {
                Mask = BitConverter.ToInt32(data, dataBegin);
                dataBegin += 4;
            }

            OpCode = (DataFrame.OpCode) nibble2;
            var someBytes = new byte[dataBegin];
            Array.Copy(data, 0, someBytes, 0, dataBegin);
            return someBytes;
        }
        public byte[] FromBytes(byte[] data, int byteCount, out int dataStartIndex)
        {
            Array.Copy(data, 0, _headerBuffer, _bufferedHeaderBytes, MaxHeaderLength - _bufferedHeaderBytes);
            byteCount     += _bufferedHeaderBytes;
            dataStartIndex = -1;

            int dataBegin = 2;
            var nibble2   = (byte)(_headerBuffer[0] & 0x0F);
            var nibble1   = (byte)(_headerBuffer[0] & 0xF0);

            IsEnd    = ((nibble1 & EndBit) == EndBit);
            IsMasked = Convert.ToBoolean((_headerBuffer[1] & 0x80) >> 7);
            int minCount = 2;

            if (IsMasked)
            {
                minCount += 4;
            }

            //Combine bytes to form one large number
            PayloadSize = (byte)(_headerBuffer[1] & 0x7F);

            switch (PayloadSize)
            {
            case 126:
                if (byteCount < minCount + 2)
                {
                    return(PartialHeader(byteCount));                              // return before modifying the header
                }
                Array.Reverse(_headerBuffer, dataBegin, 2);
                PayloadSize = BitConverter.ToUInt16(_headerBuffer, dataBegin);
                dataBegin  += 2;
                break;

            case 127:
                if (byteCount < minCount + 8)
                {
                    return(PartialHeader(byteCount));
                }
                Array.Reverse(_headerBuffer, dataBegin, 8);
                PayloadSize = BitConverter.ToUInt64(_headerBuffer, dataBegin);
                dataBegin  += 8;
                break;

            default:
                if (byteCount < minCount)
                {
                    return(PartialHeader(byteCount));
                }
                break;
            }

            PayloadSizeRemaining = PayloadSize;
            Mask             = 0;
            CurrentMaskIndex = 0;

            if (IsMasked)
            {
                Mask       = BitConverter.ToInt32(_headerBuffer, dataBegin);
                dataBegin += 4;
            }

            OpCode = (DataFrame.OpCode)nibble2;
            var someBytes = new byte[dataBegin];

            Array.Copy(_headerBuffer, 0, someBytes, 0, dataBegin);
            dataStartIndex       = dataBegin - _bufferedHeaderBytes;
            _bufferedHeaderBytes = 0;
            return(someBytes);
        }