Как правильно завершить поток сервера?

        {
 
            Listener = new TcpListener(Settings.ip, Settings.port); // Создаем "слушателя" для указанного порта
            Listener.Start(); // Запускаем его
            Settings.state = "Включен";
            // В бесконечном цикле
            while (true)
            {
                // Принимаем нового клиента
                TcpClient Client = Listener.AcceptTcpClient();
                // Создаем поток
                Thread Thread = new Thread(new ParameterizedThreadStart(ClientThread));
                // И запускаем этот поток, передавая ему принятого клиента
                Thread.Start(Client);
            }

public class ServerWrapper : IDisposable
    {
        private readonly TcpListener _listener;
        private CancellationToken _token;
        private CancellationTokenSource _tokenSource;
 
        public ServerWrapper(IPAddress address, int port) => _listener = new TcpListener(address, port);
 
        public void Dispose() => Stop();
 
        public event EventHandler<DataReceivedEventArgs> OnDataReceived;
 
        public async Task StartAsync(CancellationToken? token = null)
        {
            _tokenSource = CancellationTokenSource.CreateLinkedTokenSource(token ?? new CancellationToken());
            _token = _tokenSource.Token;
            _listener.Start();
 
            try
            {
                while (!_token.IsCancellationRequested)
                    await Task.Run(async () =>
                    {
                        var tcpClientTask = _listener.AcceptTcpClientAsync();
                        var result = await tcpClientTask;
                        OnDataReceived?.Invoke(this, new DataReceivedEventArgs(result.GetStream()));
                    }, _token).ConfigureAwait(false);
            }
            finally
            {
                _listener.Stop();
            }
        }
 
        public void Stop() => _tokenSource?.Cancel();
 
        public class DataReceivedEventArgs : EventArgs
        {
            public DataReceivedEventArgs(NetworkStream stream) => Stream = stream;
 
            public NetworkStream Stream { get; }
        }
    }

public class ClientObject
    {
        private TcpClient client;
        public ClientObject(TcpClient tcpClient)
        {
            client = tcpClient;
        }
        static public string answer = "";
        public void Process()
        {
            NetworkStream stream = null;
            try
            {
                stream = client.GetStream();
                byte[] data = new byte[128]; // буфер для получаемых данных
                while (true)
                {
                    // получаем сообщение
                    StringBuilder builder = new StringBuilder();
                    int bytes = 0;
                    do
                    {
                        bytes = stream.Read(data, 0, data.Length);
                        builder.Append(Encoding.Unicode.GetString(data, 0, bytes));
                    }
                    while (stream.DataAvailable);
                    string message = builder.ToString();//полученное сообщение
 
                    ParseMessage.Parse(message);
 
                    data = Encoding.Unicode.GetBytes(answer);
                    stream.Write(data, 0, data.Length);
                    answer = "";
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                if (stream != null)
                    stream.Close();
                if (client != null)
                    client.Close();
            }
        }
    }

static TcpListener listener =  new TcpListener(IPAddress.Parse("127.0.0.1"), 8005);
        void start(int a)
        {
            Thread clientThread = new Thread(new ThreadStart(startS));
            if (a == 1)
            {
                clientThread.Start();
            }
            else
            {
                clientThread.Abort();
                listener.Stop();
            }
        }
        void startS()
        {
            try
            {
                listener.Start();
                //listBox1.Items.Add("Ожидание подключений...");
                while (true)
                {
                    TcpClient client = listener.AcceptTcpClient();
                    ClientObject clientObject = new ClientObject(client);
                    Thread clientThread = new Thread(new ThreadStart(clientObject.Process));
                    clientThread.Start();
                }
            }
            catch //(Exception ex)
            {
                //listBox1.Items.Add(ex.Message);
            }
            finally
            {
                if (listener != null)
                    listener.Stop();
            }
        }