private byte[] buildHeader(SerializerTag tag, int length)
        {
            List <byte[]> buildHeader = new List <byte[]>()
            {
                // version: 1
                BitConverter.GetBytes(1),
                // tag:
                BitConverter.GetBytes((int)tag),
                // length:
                BitConverter.GetBytes(length)
            };

            MemoryStream packHeader = new MemoryStream();

            foreach (byte[] bs in buildHeader)
            {
                packHeader.Write(bs, 0, bs.Length);
            }

            // (3*4=12 bytes for header)
            byte[] header = packHeader.ToArray();
            Debug.Assert(header.Length == 3 * 4);

            return(header);
        }
        private async Task <bool> writeAsync(SerializerTag tag, byte[] buffer, int offset, int length)
        {
            // sanity check
            Debug.Assert(buffer.Length >= offset + length);

            // truncate write length if necessary
            if (length > WRITE_MAX)
            {
                Debug.Assert(false);
                length = WRITE_MAX;
            }

            // construct the header
            var header = buildHeader(tag, length);

            using (var lck = new AsyncLockManager(m_writeLock))
            {
                await lck.LockAsync();

                // send the header, then write the buffer
                return(await m_stream.WriteAsync(header, 0, header.Length) &&
                       await m_stream.WriteAsync(buffer, offset, length));
            }
        }