HttpClient: подключение и чтение ответа по частям

using System.Text;
using Reckfell;

public partial class HttpStreamDemo : Entity
{
    [Export] public string Url { get; set; } = "http://127.0.0.1:8765/message";
    public override void _Ready()
    {
        var reader = new HttpStreamReader(); AddChild(reader);
        reader.Completed += reply => ReckfellApi.Print($"HTTP stream: status={reply.StatusCode}, failure={reply.Failure}, bytes={reply.Body.Length}, body={Encoding.UTF8.GetString(reply.Body)}");
        Error start = reader.Start(Url);
        if (start != Error.Ok) ReckfellApi.Print($"HTTP stream start: {start}");
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using Reckfell;

public partial class HttpStreamReader : Entity
{
    public sealed record Reply(int StatusCode, byte[] Body, string[] Headers, bool Chunked, long ExpectedBytes, string Failure);
    public int MaxBytes { get; set; } = 65536;
    public double TimeoutSeconds { get; set; } = 5;
    public bool Busy => _client is not null;
    public Reply? LastReply { get; private set; }
    public event Action<Reply>? Completed;
    private HttpClient? _client;
    private readonly Stopwatch _clock = new();
    private readonly List<byte> _body = new();
    private string _path = "/";
    private bool _sent, _headersRead, _chunked;
    private int _statusCode;
    private long _expected;
    private string[] _headers = [];

    public Error Start(string url, TlsOptions? trust = null)
    {
        if (Busy) return Error.Busy;
        if (!IsInsideTree()) return Error.Unconfigured;
        if (!Uri.TryCreate(url, UriKind.Absolute, out Uri? uri) ||
            (uri.Scheme != "http" && uri.Scheme != "https") || uri.UserInfo.Length != 0 ||
            MaxBytes <= 0 || !double.IsFinite(TimeoutSeconds) || TimeoutSeconds <= 0)
            return Error.InvalidParameter;
        _body.Clear(); _headers = []; _sent = _headersRead = _chunked = false;
        _expected = -1; _statusCode = 0; LastReply = null; _path = uri.PathAndQuery;
        _client = new HttpClient { BlockingModeEnabled = false, ReadChunkSize = 4096 };
        Error error = _client.ConnectToHost(uri.DnsSafeHost, uri.Port,
            uri.Scheme == "https" ? trust ?? TlsOptions.Client() : null);
        if (error != Error.Ok) { Cancel(); return error; }
        _clock.Restart(); return Error.Ok;
    }
    public override void _Process(double delta)
    {
        if (_client is null) return;
        if (_clock.Elapsed.TotalSeconds >= TimeoutSeconds) { Finish("timeout"); return; }
        Error error = _client.Poll();
        var state = _client.GetStatus();
        if (error != Error.Ok) { Finish(state.ToString()); return; }
        if (state is HttpClient.Status.Resolving or HttpClient.Status.Connecting) return;
        if (!_sent && state == HttpClient.Status.Connected)
        {
            error = _client.Request(HttpClient.Method.Get, _path, ["Accept-Encoding: identity"]);
            if (error != Error.Ok) { Finish(error.ToString()); return; }
            _sent = true; return;
        }
        if (_sent && !_headersRead && _client.HasResponse())
        {
            _headersRead = true; _statusCode = _client.GetResponseCode();
            _headers = _client.GetResponseHeaders(); _expected = _client.GetResponseBodyLength(); _chunked = _client.IsResponseChunked();
            foreach (string header in _headers)
                if (header.StartsWith("Content-Encoding:", StringComparison.OrdinalIgnoreCase) &&
                    !header[(header.IndexOf(':') + 1)..].Trim().Equals("identity", StringComparison.OrdinalIgnoreCase))
                { Finish("content-encoding"); return; }
            if (_expected > MaxBytes) { Finish("size-limit"); return; }
        }
        if (state == HttpClient.Status.Body)
        {
            byte[] chunk = _client.ReadResponseBodyChunk();
            if (chunk.Length > MaxBytes - _body.Count) { Finish("size-limit"); return; }
            _body.AddRange(chunk); state = _client.GetStatus();
        }
        if (_headersRead && state == HttpClient.Status.Connected)
        { Finish(_expected >= 0 && _body.Count != _expected ? "truncated" : ""); return; }
        if (state == HttpClient.Status.Disconnected)
        {
            bool complete = _headersRead && ((_expected >= 0 && _body.Count == _expected) || (_expected < 0 && !_chunked));
            Finish(complete ? "" : "truncated"); return;
        }
        if (state is HttpClient.Status.CantResolve or HttpClient.Status.CantConnect or
            HttpClient.Status.ConnectionError or HttpClient.Status.TlsHandshakeError)
            Finish(state.ToString());
    }
    private void Finish(string failure)
    {
        var reply = new Reply(_statusCode, failure.Length == 0 ? _body.ToArray() : [], _headers, _chunked, _expected, failure);
        Cancel(); LastReply = reply; Completed?.Invoke(reply);
    }
    public void Cancel() { _client?.Close(); _client?.Dispose(); _client = null; _clock.Stop(); _body.Clear(); }
    public override void _ExitTree() => Cancel();
}