static void Main(string[] args)
    {
        ProxyServer.Run();
        Thread.Sleep(-1);
    }

    class ProxyServer
    {
        public static void Run()
        {
            TcpServer.Run(3000, async tcp =>
            {
                using var handlder = new ProxyHandler(tcp);
                await handlder.Process();
            });
        }
    }


    class ProxyHandler : IDisposable
    {
        TcpClient _tcp;
        TcpClient _remoteTcp;

        public ProxyHandler(TcpClient tcp)
        {
            _tcp    = tcp;
            _buffer = MemoryPool<byte>.Shared.Rent(1024 * 3);
        }

        IMemoryOwner<byte> _buffer;
        Memory<byte>       _header;

        public async Task Process()
        {
            var count = await _tcp.GetStream().ReadAsync(_buffer.Memory);
            _header = _buffer.Memory[..count];

            parseHeader(out var method, out var endPoint);

            //Console.WriteLine(endPoint);

            if (method.Equals("CONNECT", StringComparison.OrdinalIgnoreCase))
            {
                await createTunnel(endPoint);
            }
            else
            {
                await createProxy(endPoint);
            }

            await pipeStream(_tcp.GetStream(), _remoteTcp.GetStream());
        }


        static byte[] _tunnelReply = Encoding.UTF8.GetBytes("HTTP/1.0 200 Connection Established\r\n\r\n");

        async ValueTask createTunnel(string endPoint)
        {
            var host = endPoint.Split(":");

            _remoteTcp = new TcpClient();
            await _remoteTcp.ConnectAsync(host[0], int.Parse(host[1]));
            await _tcp.GetStream().WriteAsync(_tunnelReply);
        }

        async ValueTask createProxy(string endPoint)
        {
            var host = new Uri(endPoint);

            _remoteTcp = new TcpClient();
            await _remoteTcp.ConnectAsync(host.Host, host.Port);
            await _remoteTcp.GetStream().WriteAsync(_header);
        }


        void parseHeader(out string method, out string endPoint)
        {
            var reader = new SequenceReader<byte>(new ReadOnlySequence<byte>(_header));

            method   = readToSpace(ref reader);
            endPoint = readToSpace(ref reader);

            static string readToSpace(ref SequenceReader<byte> r)
            {
                //读到下一个空格
                r.TryReadTo(out ReadOnlySpan<byte> buf, (byte)‘ ‘);
                return Encoding.UTF8.GetString(buf);
            }
        }


        async Task pipeStream(Stream s1, Stream s2)
        {
            await Task.WhenAll(pipe(s1, s2), pipe(s2, s1));

            static async Task pipe(Stream source, Stream target)
            {
                try
                {
                    await source.CopyToAsync(target);
                }
                finally
                {
                    target.Close();
                    source.Close();
                }
            }
        }

        public void Dispose()
        {
            _buffer?.Dispose();
            _tcp?.Dispose();
            _remoteTcp?.Dispose();
        }
    }
    
    class TcpServer
    {
        public static async void Run(int port, Func<TcpClient, Task> handler)
        {
            var listener = new TcpListener(IPAddress.Loopback, port);

            listener.Start();
            while (true)
            {
                var tcp = await listener.AcceptTcpClientAsync();
                process(tcp, handler);
            }
        }

        static async void process(TcpClient tcp, Func<TcpClient, Task> handler)
        {
            try
            {
                await Task.Run(() => handler(tcp));
            }
            catch
            {
                // ignored
            }
        }
    }