Client.handleReceive C# (CSharp) Method

    protected void handleReceive()
    {
        while (receiveHandleIndex < receiveIndex)
        {

            //Read header bytes
            if (currentMessageHeaderIndex < KLFCommon.MSG_HEADER_LENGTH)
            {
                //Determine how many header bytes can be read
                int bytes_to_read = Math.Min(receiveIndex - receiveHandleIndex, KLFCommon.MSG_HEADER_LENGTH - currentMessageHeaderIndex);

                //Read header bytes
                Array.Copy(receiveBuffer, receiveHandleIndex, currentMessageHeader, currentMessageHeaderIndex, bytes_to_read);

                //Advance buffer indices
                currentMessageHeaderIndex += bytes_to_read;
                receiveHandleIndex += bytes_to_read;

                //Handle header
                if (currentMessageHeaderIndex >= KLFCommon.MSG_HEADER_LENGTH)
                {
                    int id_int = KLFCommon.intFromBytes(currentMessageHeader, 0);

                    //Make sure the message id section of the header is a valid value
                    if (id_int >= 0 && id_int < Enum.GetValues(typeof(KLFCommon.ServerMessageID)).Length)
                        currentMessageID = (KLFCommon.ServerMessageID)id_int;
                    else
                        currentMessageID = KLFCommon.ServerMessageID.NULL;

                    int data_length = KLFCommon.intFromBytes(currentMessageHeader, 4);

                    if (data_length > 0)
                    {
                        //Init message data buffer
                        currentMessageData = new byte[data_length];
                        currentMessageDataIndex = 0;
                    }
                    else
                    {
                        currentMessageData = null;
                        //Handle received message
                        messageReceived(currentMessageID, null);

                        //Prepare for the next header read
                        currentMessageHeaderIndex = 0;
                    }
                }
            }

            if (currentMessageData != null)
            {
                //Read data bytes
                if (currentMessageDataIndex < currentMessageData.Length)
                {
                    //Determine how many data bytes can be read
                    int bytes_to_read = Math.Min(receiveIndex - receiveHandleIndex, currentMessageData.Length - currentMessageDataIndex);

                    //Read data bytes
                    Array.Copy(receiveBuffer, receiveHandleIndex, currentMessageData, currentMessageDataIndex, bytes_to_read);

                    //Advance buffer indices
                    currentMessageDataIndex += bytes_to_read;
                    receiveHandleIndex += bytes_to_read;

                    //Handle data
                    if (currentMessageDataIndex >= currentMessageData.Length)
                    {
                        //Handle received message
                        messageReceived(currentMessageID, currentMessageData);

                        currentMessageData = null;

                        //Prepare for the next header read
                        currentMessageHeaderIndex = 0;
                    }
                }
            }

        }

        //Once all receive bytes have been handled, reset buffer indices to use the whole buffer again
        receiveHandleIndex = 0;
        receiveIndex = 0;
    }