System.Net.FrameHeader.CopyFrom C# (CSharp) Method

        public void CopyFrom(byte[] bytes, int start, FrameHeader verifier)
        {
            _MessageId = bytes[start++];
            _MajorV = bytes[start++];
            _MinorV = bytes[start++];
            _PayloadSize = (int)((bytes[start++] << 8) | bytes[start]);

            if (verifier.MessageId != FrameHeader.IgnoreValue && MessageId != verifier.MessageId)
            {
                throw new InvalidOperationException(SR.Format(SR.net_io_header_id, "MessageId", MessageId, verifier.MessageId));
            }

            if (verifier.MajorV != FrameHeader.IgnoreValue && MajorV != verifier.MajorV)
            {
                throw new InvalidOperationException(SR.Format(SR.net_io_header_id, "MajorV", MajorV, verifier.MajorV));
            }

            if (verifier.MinorV != FrameHeader.IgnoreValue && MinorV != verifier.MinorV)
            {
                throw new InvalidOperationException(SR.Format(SR.net_io_header_id, "MinorV", MinorV, verifier.MinorV));
            }
        }
    }

        public async ValueTask <byte[]?> ReadMessageAsync <TAdapter>(TAdapter adapter) where TAdapter : IReadWriteAdapter
        {
            if (_eof)
            {
                return(null);
            }

            byte[] buffer = _readHeaderBuffer;

            int bytesRead;
            int offset = 0;

            while (offset < buffer.Length)
            {
                bytesRead = await adapter.ReadAsync(buffer.AsMemory(offset)).ConfigureAwait(false);

                if (bytesRead == 0)
                {
                    if (offset == 0)
                    {
                        // m_Eof, return null
                        _eof = true;
                        return(null);
                    }

                    throw new IOException(SR.Format(SR.net_io_readfailure, SR.net_io_connectionclosed));
                }

                offset += bytesRead;
            }

            _curReadHeader.CopyFrom(buffer, 0);
            if (_curReadHeader.PayloadSize > FrameHeader.MaxMessageSize)
            {
                throw new InvalidOperationException(SR.Format(SR.net_frame_size,
                                                              FrameHeader.MaxMessageSize,
                                                              _curReadHeader.PayloadSize.ToString(NumberFormatInfo.InvariantInfo)));
            }

            buffer = new byte[_curReadHeader.PayloadSize];

            offset = 0;
            while (offset < buffer.Length)
            {
                bytesRead = await adapter.ReadAsync(buffer.AsMemory(offset)).ConfigureAwait(false);

                if (bytesRead == 0)
                {
                    throw new IOException(SR.Format(SR.net_io_readfailure, SR.net_io_connectionclosed));
                }

                offset += bytesRead;
            }
            return(buffer);
        }