C# 使用后台线程的套接字客户端

我正在尝试编写一个从服务器接收字符串的C#客户端。我创建了一个后台线程，它应该一直等待服务器的响应。当我启动程序时，我按下一个按钮（button1_Click_1）来启动发送和接收消息的线程，但我只收到一些消息（可能每10条中就有一条）。我做错了什么

System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();
Thread threadReceiveData;

string serverIP = some ip;    

static int port = 8200;

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        msg("Client Started");
        clientSocket.Connect(serverIP, port);
        msg("Client Socket Program - Server Connected ...");
    }

    private void button1_Click_1(object sender, EventArgs e)
    {
        threadReceiveData = new Thread(new ThreadStart(startReceivingTrades));
        threadReceiveData.IsBackground = true;
        threadReceiveData.Start();     
    }

    private void startReceivingTrades()
    {
        while (true)
        {

            try
            {
                NetworkStream serverStream = clientSocket.GetStream();
                byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
                serverStream.Write(outStream, 0, outStream.Length);
                serverStream.Flush();

                byte[] inStream = new byte[10025];
                serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
                string returndata = System.Text.Encoding.ASCII.GetString(inStream);
                msg("Data from Server : " + returndata);
            }

            catch (Exception ex)
            {
                msg(ex.ToString());
            }

        }
    }

---

不知道您的协议，这是有假设的，但我认为您的意思是这样的（即，您只需要获取一次流，并且只发送一次sendmestuff消息：

private void startReceivingTrades()
{
    NetworkStream serverStream;
        try
        {
            serverStream = clientSocket.GetStream();
            byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
            serverStream.Write(outStream, 0, outStream.Length);
            serverStream.Flush();
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    while (true)
    {

        try
        {
            byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
            int bytesRead = serverStream.Read(inStream, 0, (int)inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, bytesRead);
            msg("Data from Server : " + returndata);
        }
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    }
}

---

不知道您的协议，这是有假设的，但我认为您的意思是这样的（即，您只需要获取一次流，并且只发送一次sendmestuff消息：

private void startReceivingTrades()
{
    NetworkStream serverStream;
        try
        {
            serverStream = clientSocket.GetStream();
            byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
            serverStream.Write(outStream, 0, outStream.Length);
            serverStream.Flush();
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    while (true)
    {

        try
        {
            byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
            int bytesRead = serverStream.Read(inStream, 0, (int)inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, bytesRead);
            msg("Data from Server : " + returndata);
        }
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    }
}

---

不知道您的协议，这是有假设的，但我认为您的意思是这样的（即，您只需要获取一次流，并且只发送一次sendmestuff消息：

private void startReceivingTrades()
{
    NetworkStream serverStream;
        try
        {
            serverStream = clientSocket.GetStream();
            byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
            serverStream.Write(outStream, 0, outStream.Length);
            serverStream.Flush();
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    while (true)
    {

        try
        {
            byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
            int bytesRead = serverStream.Read(inStream, 0, (int)inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, bytesRead);
            msg("Data from Server : " + returndata);
        }
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    }
}

---

不知道您的协议，这是有假设的，但我认为您的意思是这样的（即，您只需要获取一次流，并且只发送一次sendmestuff消息：

private void startReceivingTrades()
{
    NetworkStream serverStream;
        try
        {
            serverStream = clientSocket.GetStream();
            byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
            serverStream.Write(outStream, 0, outStream.Length);
            serverStream.Flush();
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    while (true)
    {

        try
        {
            byte[] inStream = new byte[clientSocket.ReceiveBufferSize];
            int bytesRead = serverStream.Read(inStream, 0, (int)inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, bytesRead);
            msg("Data from Server : " + returndata);
        }
        catch (Exception ex)
        {
            msg(ex.ToString());
        }

    }
}

---

当一个TCP问题出现时，我立即进入第一个

Read

调用，因为我总是发现它的返回值未使用。使用它的返回值来确定实际接收了多少字节。

当一个TCP问题出现时，我立即进入第一个

Read

调用，因为我总是发现它的返回值未使用。Us查看其返回值以了解实际接收的字节数。

当TCP问题出现时，我立即转到第一个

读取

调用，因为我总是发现其返回值未使用。使用其返回值以了解实际接收的字节数。

当TCP问题出现时，我立即转到第一个调用de>Read调用，因为我总是发现它的返回值未被使用。使用它的返回值来确定实际接收了多少字节。

您的意思是要连续发送“SendMeStuff”吗？这似乎更像是只应在循环外发送一次

另外，在GetString（）调用中使用返回值from Read（），并传递实际使用的缓冲区长度：

private void startReceivingTrades()
{
    NetworkStream serverStream = clientSocket.GetStream();
    byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
    serverStream.Write(outStream, 0, outStream.Length);
    serverStream.Flush();

    byte[] inStream = new byte[10025];
    while (true)
    {
        try
        {
            int count = serverStream.Read(inStream, 0, inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, count);
            msg("Data from Server : " + returndata);
        }

        catch (Exception ex)
        {
            msg(ex.ToString());
        }
    }
}

您的意思是要连续发送“SendMeStuff”吗？看起来更像是只应在循环之外发送一次

另外，在GetString（）调用中使用返回值from Read（），并传递实际使用的缓冲区长度：

private void startReceivingTrades()
{
    NetworkStream serverStream = clientSocket.GetStream();
    byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
    serverStream.Write(outStream, 0, outStream.Length);
    serverStream.Flush();

    byte[] inStream = new byte[10025];
    while (true)
    {
        try
        {
            int count = serverStream.Read(inStream, 0, inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, count);
            msg("Data from Server : " + returndata);
        }

        catch (Exception ex)
        {
            msg(ex.ToString());
        }
    }
}

您的意思是要连续发送“SendMeStuff”吗？看起来更像是只应在循环之外发送一次

另外，在GetString（）调用中使用返回值from Read（），并传递实际使用的缓冲区长度：

private void startReceivingTrades()
{
    NetworkStream serverStream = clientSocket.GetStream();
    byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
    serverStream.Write(outStream, 0, outStream.Length);
    serverStream.Flush();

    byte[] inStream = new byte[10025];
    while (true)
    {
        try
        {
            int count = serverStream.Read(inStream, 0, inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, count);
            msg("Data from Server : " + returndata);
        }

        catch (Exception ex)
        {
            msg(ex.ToString());
        }
    }
}

您的意思是要连续发送“SendMeStuff”吗？看起来更像是只应在循环之外发送一次

另外，在GetString（）调用中使用返回值from Read（），并传递实际使用的缓冲区长度：

private void startReceivingTrades()
{
    NetworkStream serverStream = clientSocket.GetStream();
    byte[] outStream = System.Text.Encoding.ASCII.GetBytes("SendMeStuff" + System.Environment.NewLine);
    serverStream.Write(outStream, 0, outStream.Length);
    serverStream.Flush();

    byte[] inStream = new byte[10025];
    while (true)
    {
        try
        {
            int count = serverStream.Read(inStream, 0, inStream.Length);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream, 0, count);
            msg("Data from Server : " + returndata);
        }

        catch (Exception ex)
        {
            msg(ex.ToString());
        }
    }
}

---

---

哎呀，请参阅更正（无法访问编译器atm。感谢您的回复-这仍然不起作用。我在serverstream.read（）上设置了一个断点程序到达的行阻塞了线程，当我发送它时，它什么也不做4条消息

Read

应该在某些数据可用时解除阻塞…所以这有点奇怪，它不…不确定这里发生了什么…哦，请参阅更正（没有访问编译器atm的权限。感谢您的回复-但仍然不起作用。我在serverstream.read（）上设置了一个断点）程序到达的行阻塞了线程，当我发送它时，它什么也不做4条消息

Read

应该在某些数据可用时解除阻塞…所以这有点奇怪，它不…不确定这里发生了什么…哦，请参阅更正（没有访问编译器atm的权限。感谢您的回复-但仍然不起作用。我在serverstream.read（）上设置了一个断点）程序到达的行阻塞了线程，当我发送它时，它什么也不做4条消息

Read

应该在某些数据可用时解除阻塞…所以这有点奇怪，它不…不确定这里发生了什么…哦，请参阅更正（没有访问编译器atm的权限。感谢您的回复-但仍然不起作用。我在serverstream.read（）上设置了一个断点）程序到达的行阻塞了线程，当我向它发送4条消息时，它什么也不做。

Read

应该在某些数据可用时解除阻塞…所以这有点奇怪，它不…不确定这里发生了什么…只是好奇，这两种方法之间有什么区别？在存储服务器返回值之间Stream.Read（）而不存储它？为什么存储它时它工作，而不存储它时它不工作？因为您的缓冲区

inStream

可能没有“满”有效数据。您无法控制数量（或时间）接收数据，因此您应该只使用已知包含有效数据的缓冲区部分…返回值告诉您接收并放入缓冲区的字节数。此信息允许您，或GetString（）在这种情况下，仅正确转换缓冲区中包含有效数据的部分。数组的其余部分仅包含垃圾。实际上，我仍然没有收到所有消息！什么是

msg（“来自服务器的数据：”+returndata）

do？如果您需要更好的帮助，您必须向我们提供更多详细信息。您如何知道您没有收到所有消息？您实际收到的是什么？…您期望的是什么？很抱歉造成混淆-服务器端有一个错误，其他程序员正在查看。谢谢您的帮助！只是好奇，d是什么两种方法之间的区别？存储返回值fr