// обёртка для Stream, для перехвата текстовых данных в UTF-8
public class TextSnifferStream : Stream
{
   // input - оригинальный поток, куда будут писать
   // output - поток, куда надо перехватить данные
   // maxSize - максимальное количество байт для перехвата
   public TextSnifferStream(Stream input, Stream output, long maxSize)
   {
   }

   ...
}

Encoding.UTF8.GetBytes("Привет!")

    public class TextSnifferStream : Stream
    {
        private readonly Stream _input;
        private readonly Stream _sniffOutput;
        private readonly int _sniffMaxBytes;

        // в результате работы в sniffOutput должно оказаться не более sniffMaxBytes байт
        // корректного текста UTF-8
        public TextSnifferStream(Stream input, Stream sniffOutput, int sniffMaxBytes)
        {
            _input = input;
            _sniffOutput = sniffOutput;
            _sniffMaxBytes = sniffMaxBytes;
        }

        // нужно реализовать этот метод
        private void WriteToTarget(byte[] buffer, int offset, int count)
        {
            // ???
        }
        
        public override void Flush()
        {
            _input.Flush();
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            throw new NotImplementedException();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return _input.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            _input.SetLength(value);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            // здесь мы снифаем запись
            WriteToTarget(buffer, offset, count);
            _input.Write(buffer, offset, count);
        }

        public override bool CanRead => _input.CanRead;

        public override bool CanSeek => _input.CanSeek;

        public override bool CanWrite => _input.CanWrite;

        public override long Length => _input.Length;

        public override long Position
        {
            get => _input.Position;
            set => _input.Position = value;
        }
    }

var input = new MemoryStream();
var sniffedOutput = new MemoryStream();

var sniffedInput = new TextSnifferStream(input, sniffedOutput, 5);

var buffer = Encoding.UTF8.GetBytes("Привет!");

sniffedInput.Write(buffer, 0, buffer.Length);
sniffedInput.Flush();

Assert.Equals("Пр", Encoding.UTF8.GetString(sniffedOutput.ToArray());

    /// <summary>
    ///     Обёртка потока для перехвата записи или чтения текстовых данных в указанной кодировке.
    /// </summary>
    public class StringSnifferStream : Stream
    {
        private const int CharBufferLen = 128;

        private readonly Stream _source;
        private readonly long _sniffMaxBytes;
        private readonly Encoding _encoding;
        private readonly Decoder _decoder;
        private readonly StringBuilder _stringBuilder;

        private bool _checkPreamble;
        private bool _sniffRead;
        private bool _sniffWrite;
        private long _sniffBytes;

        /// <summary>
        ///     Создать экземпляр перехватчика потока.
        /// </summary>
        /// <param name="source">Исходный поток.</param>
        /// <param name="snifferWay">Направление перехвата.</param>
        /// <param name="sniffMaxBytes">Максимальное количество байт, которые будут перехвачены.</param>
        /// <param name="encoding">Кодировка для извлечения текста (по умолчанию UTF-8).</param>
        /// <exception cref="ArgumentException"><paramref name="sniffMaxBytes"/> должно быть больше нуля.</exception>
        public StringSnifferStream(
            Stream source,
            SnifferWay snifferWay,
            long sniffMaxBytes,
            Encoding? encoding = null)
        {
            if (sniffMaxBytes <= 0)
                throw new ArgumentException("Value must be greater than zero.", nameof(sniffMaxBytes));
            _source = source;
            _sniffMaxBytes = sniffMaxBytes;
            _encoding = encoding ?? Encoding.UTF8;
            _decoder = _encoding.GetDecoder();
            _stringBuilder = new StringBuilder();
            
            _sniffRead = snifferWay == SnifferWay.Read || snifferWay == SnifferWay.Both;
            _sniffWrite = snifferWay == SnifferWay.Write || snifferWay == SnifferWay.Both;
            
            var preamble = encoding.Preamble;
            _checkPreamble = preamble.Length > 0 && preamble.Length <= sniffMaxBytes;
        }

        // перехват данных
        private void Sniff(ReadOnlySpan<byte> buffer)
        {
            _sniffBytes += buffer.Length;

            // следим за превышением лимита
            if (_sniffBytes >= _sniffMaxBytes)
            {
                if (_sniffBytes > _sniffMaxBytes)
                    buffer = buffer.Slice(0, buffer.Length - (int) (_sniffBytes - _sniffMaxBytes));
                // отключаем перехват
                _sniffRead = false;
                _sniffWrite = false;
            }

            // на всякий случай чекаем маркер юникода (BOM)
            if (_checkPreamble)
            {
                _checkPreamble = false;
                var offset = GetPreambleOffset(buffer);
                if (offset > 0)
                {
                    if(offset == buffer.Length) 
                        return;
                    buffer = buffer.Slice(offset);
                }
            }

            // собственно декодируем байты в символы
            Span<char> charBuffer = stackalloc char[CharBufferLen];
            for (var offset = 0; offset < buffer.Length; offset += CharBufferLen)
            {
                var readBuffer = buffer.Slice(offset, Math.Min(buffer.Length - offset, CharBufferLen));
                var charsCount = _decoder.GetChars(readBuffer, charBuffer, false);
                if (charsCount > 0)
                    _stringBuilder.Append(charsCount == CharBufferLen ? charBuffer : charBuffer.Slice(0, charsCount));
            }
        }

        // реальное смещение в байтах заголовка кодировки
        private int GetPreambleOffset(ReadOnlySpan<byte> buffer)
        {
            var preamble = _encoding.Preamble;
            if (preamble.IsEmpty || preamble.Length > buffer.Length) return 0;
            for (var i = 0; i < preamble.Length; i++)
            {
                if (buffer[i] != preamble[i]) return 0;
            }
            return preamble.Length;
        }

        /// <summary>
        ///     Получить строку, содержащую перехваченный текст.
        /// </summary>
        public string GetStringContent() => _stringBuilder.ToString();

        #region Overrides of Stream

        /// <inheritdoc />
        public override void Close() => _source.Close();

        /// <inheritdoc />
        public override ValueTask DisposeAsync() => _source.DisposeAsync();

        /// <inheritdoc />
        protected override void Dispose(bool disposing)
        {
            if (disposing) _source.Dispose();
        }

        /// <inheritdoc />
        public override void Flush() => _source.Flush();

        /// <inheritdoc />
        public override Task FlushAsync(CancellationToken cancellationToken) => _source.FlushAsync(cancellationToken);

        /// <inheritdoc />
        public override int Read(byte[] buffer, int offset, int count)
        {
            var readCount = _source.Read(buffer, offset, count);
            if (_sniffRead)
            {
                Sniff(new ReadOnlySpan<byte>(buffer, offset, readCount));
            }

            return readCount;
        }

        /// <inheritdoc />
        public override int Read(Span<byte> buffer)
        {
            var readCount = _source.Read(buffer);
            if (_sniffRead)
            {
                Sniff(buffer);
            }

            return readCount;
        }

        /// <inheritdoc />
        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
            CancellationToken cancellationToken)
        {
            var readCount = await _source.ReadAsync(buffer, offset, count, cancellationToken);
            if (_sniffRead)
            {
                Sniff(new Span<byte>(buffer, offset, readCount));
            }

            return readCount;
        }

        /// <inheritdoc />
        public override async ValueTask<int> ReadAsync(Memory<byte> buffer,
            CancellationToken cancellationToken = new CancellationToken())
        {
            var readCount = await _source.ReadAsync(buffer, cancellationToken);
            if (_sniffRead)
            {
                Sniff(buffer.Length == readCount
                    ? buffer.Span
                    : buffer.Span.Slice(0, readCount));
            }

            return readCount;
        }

        /// <inheritdoc />
        public override long Seek(long offset, SeekOrigin origin) =>
            throw new NotSupportedException("Seek not supported for sniffed streams.");

        /// <inheritdoc />
        public override void SetLength(long value) => _source.SetLength(value);

        /// <inheritdoc />
        public override void Write(byte[] buffer, int offset, int count)
        {
            if (_sniffWrite)
            {
                Sniff(new ReadOnlySpan<byte>(buffer, offset, count));
            }

            _source.Write(buffer, offset, count);
        }

        /// <inheritdoc />
        public override void Write(ReadOnlySpan<byte> buffer)
        {
            if (_sniffWrite)
            {
                Sniff(buffer);
            }

            _source.Write(buffer);
        }

        /// <inheritdoc />
        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            if (_sniffWrite)
            {
                Sniff(new ReadOnlySpan<byte>(buffer, offset, count));
            }

            return _source.WriteAsync(buffer, offset, count, cancellationToken);
        }

        /// <inheritdoc />
        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer,
            CancellationToken cancellationToken = new CancellationToken())
        {
            if (_sniffWrite)
            {
                Sniff(buffer.Span);
            }

            return _source.WriteAsync(buffer, cancellationToken);
        }

        /// <inheritdoc />
        public override bool CanRead => _source.CanRead;

        /// <inheritdoc />
        public override bool CanSeek => false;

        /// <inheritdoc />
        public override bool CanTimeout => _source.CanTimeout;

        /// <inheritdoc />
        public override bool CanWrite => _source.CanWrite;

        /// <inheritdoc />
        public override long Length => _source.Length;

        /// <inheritdoc />
        public override long Position
        {
            get => _source.Position;
            set => throw new NotSupportedException("Change position not supported for sniffed streams.");
        }

        /// <inheritdoc />
        public override int ReadTimeout
        {
            get => _source.ReadTimeout;
            set => _source.ReadTimeout = value;
        }

        /// <inheritdoc />
        public override int WriteTimeout
        {
            get => _source.WriteTimeout;
            set => _source.WriteTimeout = value;
        }

        #endregion
    }

    /// <summary>
    ///     Направление перехвата записи.
    /// </summary>
    public enum SnifferWay
    {
        /// <summary>
        ///     Чтение и запись.
        /// </summary>
        Both,
        
        /// <summary>
        ///     Только чтение.
        /// </summary>
        Read,
        
        /// <summary>
        ///     Только запись.
        /// </summary>
        Write
    }

    public class StringSnifferStreamTests
    {
        [Theory]
        [InlineData("х_эй", 1, "")]
        [InlineData("х_эй", 2, "х")]
        [InlineData("х_эй", 3, "х_")]
        [InlineData("х_эй", 4, "х_")]
        [InlineData("х_эй", 5, "х_э")]
        [InlineData("х_эй", 6, "х_э")]
        [InlineData("х_эй", 7, "х_эй")]
        [InlineData("х_эй", 8, "х_эй")]
        public void Test1(string source, int sniffMaxCount, string expected)
        {
            var stream = new MemoryStream();
            var sniffer = new StringSnifferStream(stream, SnifferWay.Both, sniffMaxCount, Encoding.UTF8);
            var bytes = Encoding.UTF8.GetBytes(source);
            sniffer.Write(bytes);

            // ожидаемый вывод
            var output = sniffer.GetStringContent();
            Assert.Equal(expected, output);

            // в оригинальный поток должны попасть все байты
            var writeBytes = stream.ToArray();
            Assert.Equal(bytes, writeBytes);
        }
    }