Tcpclient简单聊天程序

以前C/S通讯这一块都是基于套接字(Sockets)编程，但是面对业务逻辑复杂的C/S系统，通讯这一块往往都是被封装好了的，前几天写的一个小小窗体聊天程序，主要是练习一下C#封装的TcpListener、TcpClient以及NetworkStream的使用，直接看图上代码：

[csharp] view plaincopyprint?

  1. using System;
  2. using System.Drawing;
  3. using System.Collections;
  4. using System.ComponentModel;
  5. using System.Windows.Forms;
  6. using System.Data;
  7. using System.Net;
  8. using System.Net.Sockets;
  9. using System.Threading;
  10. using System.IO;
  11. namespace ChartTestServer
  12. {
  13. public partial class Form1 : Form
  14. {
  15. public Form1()
  16. {
  17. InitializeComponent();
  18. }
  19. private NetworkStream networkStream;
  20. private StreamReader streamReader;
  21. private StreamWriter streamWriter;
  22. private Socket socketForClient;
  23. private TcpListener tcpListener;
  24. private Thread serverThread;// 启动服务线程
  25. private Thread recvThread;// 接收信息线程
  26. private void button1_Click(object sender, EventArgs e)
  27. {
  28. serverThread = new Thread(new ThreadStart(Listen));
  29. serverThread.Start();
  30. }
  31. //[STAThread]
  32. private void Listen()
  33. {
  34. try
  35. {
  36. Int32 port = Int32.Parse(txtPort.Text);
  37. IPAddress ipAddress = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];
  38. tcpListener = new TcpListener(ipAddress, port);
  39. // 开始侦听
  40. tcpListener.Start();
  41. listBox1.Items.Add("服务已经启动！");
  42. button1.Enabled = false;
  43. button2.Enabled = true;
  44. // 返回可以用以处理连接的Socket实例
  45. socketForClient = tcpListener.AcceptSocket();
  46. // 如果返回值是"true"，则产生的套节字已经接受来自远方的连接请求
  47. if (socketForClient.Connected)
  48. {
  49. button3.Enabled = true;
  50. listBox1.Items.Add("客户端成功连接上服务器!");
  51. // 创建networkStream对象通过网络套节字来接受和发送数据
  52. networkStream = new NetworkStream(socketForClient);
  53. // 从当前数据流中读取一行字符，返回值是字符串
  54. streamReader = new StreamReader(networkStream);
  55. streamWriter = new StreamWriter(networkStream);
  56. recvThread = new Thread(new ThreadStart(RecvData));
  57. recvThread.Start();
  58. }
  59. }
  60. catch (Exception exc)
  61. {
  62. MessageBox.Show(exc.Message, "Server提示");
  63. }
  64. }
  65. // 接收服务器发来的信息
  66. private void RecvData()
  67. {
  68. string msg = streamReader.ReadLine();
  69. // 如果不是接收到客户端发来的退出信息，则不断接收信息
  70. while (!msg.Equals("exit"))
  71. {
  72. //statusChart1.Value = Convert.ToInt32(msg);
  73. listBox1.Items.Add("收到信息: " + msg);
  74. msg = streamReader.ReadLine();
  75. }
  76. // 如果接收到客户的退出信息，则退出服务
  77. button1.Enabled = true;
  78. button2.Enabled = false;
  79. button3.Enabled = false;
  80. listBox1.Items.Add("客户已经关闭");
  81. listBox1.Items.Add("服务器关闭");
  82. // 关闭资源
  83. ReleaseResource();
  84. }
  85. private void button3_Click(object sender, EventArgs e)
  86. {
  87. Thread sendThread = new Thread(new ThreadStart(SendData));
  88. sendThread.Start();
  89. }
  90. private void SendData()
  91. {
  92. if (txtMsg.Text != "")
  93. {
  94. listBox1.Items.Add("发送信息: " + txtMsg.Text);
  95. // 往当前的数据流中写入一行字符串
  96. streamWriter.WriteLine(txtMsg.Text);
  97. // 刷新当前数据流中的数据
  98. streamWriter.Flush();
  99. txtMsg.Text = ""; // 清空
  100. }
  101. else
  102. {
  103. MessageBox.Show("发送信息不能为空","提示");
  104. }
  105. }
  106. private void button2_Click(object sender, EventArgs e)
  107. {
  108. try
  109. {
  110. if (button3.Enabled == true)
  111. {
  112. // 停止服务后，允许 启动服务，但是不允许发送消息
  113. button1.Enabled = true;
  114. button2.Enabled = false;
  115. button3.Enabled = false;
  116. string exitMsg = "exit"; // 要退出时，发送 exit 信息给客户端
  117. streamWriter.WriteLine(exitMsg);
  118. // 刷新当前数据流中的数据
  119. streamWriter.Flush();
  120. listBox1.Items.Add("服务器关闭");
  121. // 释放资源
  122. recvThread.Abort();
  123. ReleaseResource();
  124. }
  125. else
  126. {
  127. // 停止服务后，允许 启动服务，但是不允许发送消息
  128. button1.Enabled = true;
  129. button2.Enabled = false;
  130. button3.Enabled = false;
  131. listBox1.Items.Add("服务器关闭");
  132. // 关闭TCP连接，关闭线程
  133. tcpListener.Stop();
  134. serverThread.Abort();
  135. }
  136. }
  137. catch (Exception exc)
  138. {
  139. MessageBox.Show(exc.Message, "Server提示");
  140. }
  141. }
  142. // 释放资源
  143. private void ReleaseResource()
  144. {
  145. networkStream.Close();
  146. streamReader.Close();
  147. streamWriter.Close();
  148. socketForClient.Shutdown(SocketShutdown.Both);
  149. socketForClient.Close();
  150. tcpListener.Stop();
  151. }
  152. private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  153. {
  154. // 在未停止 服务 前，不允许关闭窗体
  155. if (button1.Enabled == false)
  156. {
  157. MessageBox.Show("请先停止服务!", "Server提示");
  158. e.Cancel = true;
  159. }
  160. }
  161. private void Form1_Load(object sender, EventArgs e)
  162. {
  163. // 在没有启动服务器之前，不允许停止服务以及发送信息
  164. button2.Enabled = false;
  165. button3.Enabled = false;
  166. }
  167. }

[csharp] view plain copy print?

  1. using System;
  2. using System.Drawing;
  3. using System.Collections;
  4. using System.ComponentModel;
  5. using System.Windows.Forms;
  6. using System.Data;
  7. using System.Net;
  8. using System.Net.Sockets;
  9. using System.Threading;
  10. using System.IO;
  11. namespace ChartTestServer
  12. {
  13. public partial class Form1 : Form
  14. {
  15. public Form1()
  16. {
  17. InitializeComponent();
  18. }
  19. private NetworkStream networkStream;
  20. private StreamReader streamReader;
  21. private StreamWriter streamWriter;
  22. private Socket socketForClient;
  23. private TcpListener tcpListener;
  24. private Thread serverThread;   // 启动服务线程
  25. private Thread recvThread;// 接收信息线程
  26. private void button1_Click(object sender, EventArgs e)
  27. {
  28. serverThread = new Thread(new ThreadStart(Listen));
  29. serverThread.Start();
  30. }
  31. //[STAThread]
  32. private void Listen()
  33. {
  34. try
  35. {
  36. Int32 port = Int32.Parse(txtPort.Text);
  37. IPAddress ipAddress = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];
  38. tcpListener = new TcpListener(ipAddress, port);
  39. // 开始侦听
  40. tcpListener.Start();
  41. listBox1.Items.Add("服务已经启动！");
  42. button1.Enabled = false;
  43. button2.Enabled = true;
  44. // 返回可以用以处理连接的Socket实例
  45. socketForClient = tcpListener.AcceptSocket();
  46. // 如果返回值是"true"，则产生的套节字已经接受来自远方的连接请求
  47. if (socketForClient.Connected)
  48. {
  49. button3.Enabled = true;
  50. listBox1.Items.Add("客户端成功连接上服务器!");
  51. // 创建networkStream对象通过网络套节字来接受和发送数据
  52. networkStream = new NetworkStream(socketForClient);
  53. // 从当前数据流中读取一行字符，返回值是字符串
  54. streamReader = new StreamReader(networkStream);
  55. streamWriter = new StreamWriter(networkStream);
  56. recvThread = new Thread(new ThreadStart(RecvData));
  57. recvThread.Start();
  58. }
  59. }
  60. catch (Exception exc)
  61. {
  62. MessageBox.Show(exc.Message, "Server提示");
  63. }
  64. }
  65. // 接收服务器发来的信息
  66. private void RecvData()
  67. {
  68. string msg = streamReader.ReadLine();
  69. // 如果不是接收到客户端发来的退出信息，则不断接收信息
  70. while (!msg.Equals("exit"))
  71. {
  72. //statusChart1.Value = Convert.ToInt32(msg);
  73. listBox1.Items.Add("收到信息: " + msg);
  74. msg = streamReader.ReadLine();
  75. }
  76. // 如果接收到客户的退出信息，则退出服务
  77. button1.Enabled = true;
  78. button2.Enabled = false;
  79. button3.Enabled = false;
  80. listBox1.Items.Add("客户已经关闭");
  81. listBox1.Items.Add("服务器关闭");
  82. // 关闭资源
  83. ReleaseResource();
  84. }
  85. private void button3_Click(object sender, EventArgs e)
  86. {
  87. Thread sendThread = new Thread(new ThreadStart(SendData));
  88. sendThread.Start();
  89. }
  90. private void SendData()
  91. {
  92. if (txtMsg.Text != "")
  93. {
  94. listBox1.Items.Add("发送信息: " + txtMsg.Text);
  95. // 往当前的数据流中写入一行字符串
  96. streamWriter.WriteLine(txtMsg.Text);
  97. // 刷新当前数据流中的数据
  98. streamWriter.Flush();
  99. txtMsg.Text = "";  // 清空
  100. }
  101. else
  102. {
  103. MessageBox.Show("发送信息不能为空", "提示");
  104. }
  105. }
  106. private void button2_Click(object sender, EventArgs e)
  107. {
  108. try
  109. {
  110. if (button3.Enabled == true)
  111. {
  112. // 停止服务后，允许 启动服务，但是不允许发送消息
  113. button1.Enabled = true;
  114. button2.Enabled = false;
  115. button3.Enabled = false;
  116. string exitMsg = "exit";  // 要退出时，发送 exit 信息给客户端
  117. streamWriter.WriteLine(exitMsg);
  118. // 刷新当前数据流中的数据
  119. streamWriter.Flush();
  120. listBox1.Items.Add("服务器关闭");
  121. // 释放资源
  122. recvThread.Abort();
  123. ReleaseResource();
  124. }
  125. else
  126. {
  127. // 停止服务后，允许 启动服务，但是不允许发送消息
  128. button1.Enabled = true;
  129. button2.Enabled = false;
  130. button3.Enabled = false;
  131. listBox1.Items.Add("服务器关闭");
  132. // 关闭TCP连接，关闭线程
  133. tcpListener.Stop();
  134. serverThread.Abort();
  135. }
  136. }
  137. catch (Exception exc)
  138. {
  139. MessageBox.Show(exc.Message, "Server提示");
  140. }
  141. }
  142. // 释放资源
  143. private void ReleaseResource()
  144. {
  145. networkStream.Close();
  146. streamReader.Close();
  147. streamWriter.Close();
  148. socketForClient.Shutdown(SocketShutdown.Both);
  149. socketForClient.Close();
  150. tcpListener.Stop();
  151. }
  152. private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  153. {
  154. // 在未停止 服务 前，不允许关闭窗体
  155. if (button1.Enabled == false)
  156. {
  157. MessageBox.Show("请先停止服务!", "Server提示");
  158. e.Cancel = true;
  159. }
  160. }
  161. private void Form1_Load(object sender, EventArgs e)
  162. {
  163. // 在没有启动服务器之前，不允许停止服务以及发送信息
  164. button2.Enabled = false;
  165. button3.Enabled = false;
  166. }
  167. }
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.IO;

namespace ChartTestServer
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private NetworkStream networkStream;
        private StreamReader streamReader;
        private StreamWriter streamWriter;
        private Socket socketForClient;
        private TcpListener tcpListener;
        private Thread serverThread;   // 启动服务线程
        private Thread recvThread;// 接收信息线程

        private void button1_Click(object sender, EventArgs e)
        {
            serverThread = new Thread(new ThreadStart(Listen));
            serverThread.Start();
        }

        //[STAThread]

        private void Listen()
        {
            try
            {
                Int32 port = Int32.Parse(txtPort.Text);
                IPAddress ipAddress = Dns.GetHostEntry(Dns.GetHostName()).AddressList[0];
                tcpListener = new TcpListener(ipAddress, port);
                // 开始侦听
                tcpListener.Start();
                listBox1.Items.Add("服务已经启动！");
                button1.Enabled = false;
                button2.Enabled = true;

                // 返回可以用以处理连接的Socket实例
                socketForClient = tcpListener.AcceptSocket();

                // 如果返回值是"true"，则产生的套节字已经接受来自远方的连接请求
                if (socketForClient.Connected)
                {
                    button3.Enabled = true;
                    listBox1.Items.Add("客户端成功连接上服务器!");
                    // 创建networkStream对象通过网络套节字来接受和发送数据
                    networkStream = new NetworkStream(socketForClient);
                    // 从当前数据流中读取一行字符，返回值是字符串
                    streamReader = new StreamReader(networkStream);
                    streamWriter = new StreamWriter(networkStream);
                    recvThread = new Thread(new ThreadStart(RecvData));
                    recvThread.Start();
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Server提示");
            }

        }

        // 接收服务器发来的信息
        private void RecvData()
        {
            string msg = streamReader.ReadLine();
            // 如果不是接收到客户端发来的退出信息，则不断接收信息
            while (!msg.Equals("exit"))
            {
                //statusChart1.Value = Convert.ToInt32(msg);
                listBox1.Items.Add("收到信息: " + msg);
                msg = streamReader.ReadLine();
            }
            // 如果接收到客户的退出信息，则退出服务
            button1.Enabled = true;
            button2.Enabled = false;
            button3.Enabled = false;
            listBox1.Items.Add("客户已经关闭");
            listBox1.Items.Add("服务器关闭");
            // 关闭资源
            ReleaseResource();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            Thread sendThread = new Thread(new ThreadStart(SendData));
            sendThread.Start();
        }

        private void SendData()
        {
            if (txtMsg.Text != "")
            {
                listBox1.Items.Add("发送信息: " + txtMsg.Text);
                // 往当前的数据流中写入一行字符串
                streamWriter.WriteLine(txtMsg.Text);
                // 刷新当前数据流中的数据
                streamWriter.Flush();
                txtMsg.Text = "";  // 清空
            }
            else
            {
                MessageBox.Show("发送信息不能为空", "提示");
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                if (button3.Enabled == true)
                {
                    // 停止服务后，允许 启动服务，但是不允许发送消息
                    button1.Enabled = true;
                    button2.Enabled = false;
                    button3.Enabled = false;
                    string exitMsg = "exit";  // 要退出时，发送 exit 信息给客户端
                    streamWriter.WriteLine(exitMsg);
                    // 刷新当前数据流中的数据
                    streamWriter.Flush();
                    listBox1.Items.Add("服务器关闭");

                    // 释放资源
                    recvThread.Abort();
                    ReleaseResource();
                }
                else
                {
                    // 停止服务后，允许 启动服务，但是不允许发送消息
                    button1.Enabled = true;
                    button2.Enabled = false;
                    button3.Enabled = false;
                    listBox1.Items.Add("服务器关闭");

                    // 关闭TCP连接，关闭线程
                    tcpListener.Stop();
                    serverThread.Abort();
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "Server提示");
            }
        }

        // 释放资源
        private void ReleaseResource()
        {
            networkStream.Close();
            streamReader.Close();
            streamWriter.Close();
            socketForClient.Shutdown(SocketShutdown.Both);
            socketForClient.Close();
            tcpListener.Stop();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在未停止 服务 前，不允许关闭窗体
            if (button1.Enabled == false)
            {
                MessageBox.Show("请先停止服务!", "Server提示");
                e.Cancel = true;
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // 在没有启动服务器之前，不允许停止服务以及发送信息
            button2.Enabled = false;
            button3.Enabled = false;
        }

    }

[csharp] view plaincopyprint?

  1. using System;
  2. using System.Drawing;
  3. using System.Collections;
  4. using System.ComponentModel;
  5. using System.Windows.Forms;
  6. using System.Data;
  7. using System.Net;
  8. using System.Net.Sockets;
  9. using System.Threading;
  10. using System.IO;
  11. namespace ChartTest
  12. {
  13. public partial class Form1 : Form
  14. {
  15. public Form1()
  16. {
  17. InitializeComponent();
  18. }
  19. private NetworkStream networkStream;
  20. private StreamReader streamReader;
  21. private StreamWriter streamWriter;
  22. private TcpClient myclient;
  23. private Thread recvThread; // 接收信息线程
  24. private Thread sendThread;// 发送信息线程
  25. private Thread serverThread;// 服务线程
  26. private Thread st;
  27. private void button1_Click(object sender, EventArgs e)
  28. {
  29. serverThread = new Thread(new ThreadStart(Connection));
  30. serverThread.Start();
  31. }
  32. private void Connection()
  33. {
  34. /*
  35. try
  36. {
  37. IPAddress ipAddress = IPAddress.Parse(txtIP.Text);
  38. Int32 port = Int32.Parse(txtPort.Text);
  39. IPEndPoint ipe = new IPEndPoint(ipAddress, port);
  40. myclient = new TcpClient();
  41. myclient.Connect(ipe);
  42. }
  43. catch
  44. {
  45. MessageBox.Show("没有连接到服务器!");
  46. return;
  47. }
  48. */
  49. try
  50. {
  51. IPAddress ipAddress = IPAddress.Parse(txtIP.Text);
  52. Int32 port = Int32.Parse(txtPort.Text);
  53. string hostName = Dns.GetHostEntry(ipAddress).HostName;
  54. myclient = new TcpClient(hostName, port);
  55. }
  56. catch
  57. {
  58. MessageBox.Show("没有连接到服务器!");
  59. return;
  60. }
  61. listBox1.Items.Add("客户端成功连接上服务器!");
  62. button1.Enabled = false; // 连接上了，不让按“连接”按钮
  63. button2.Enabled = true;
  64. button3.Enabled = true;
  65. networkStream = myclient.GetStream();
  66. streamReader = new StreamReader(networkStream);
  67. streamWriter = new StreamWriter(networkStream);
  68. // 创建接收信息线程，并启动
  69. recvThread = new Thread(new ThreadStart(RecvData));
  70. recvThread.Start();
  71. }
  72. // 接收数据
  73. private void RecvData()
  74. {
  75. string s = streamReader.ReadLine();
  76. // 如果没接到服务器退出的消息，则继续接收信息
  77. while (s!=null&&!s.Equals("exit"))
  78. {
  79. listBox1.Items.Add("收到信息:" + s);
  80. s = streamReader.ReadLine();
  81. }
  82. // 收到服务器退出的消息，释放资源
  83. listBox1.Items.Add("服务器关闭");
  84. listBox1.Items.Add("客户端关闭");
  85. button1.Enabled = true;
  86. button2.Enabled = false;
  87. button3.Enabled = false;
  88. // streamReader.Close();
  89. // streamWriter.Close();
  90. // networkStream.Close();
  91. // myclient.Close();
  92. ReleaseResouce();
  93. }
  94. private void button2_Click(object sender, EventArgs e)
  95. {
  96. button1.Enabled = true; // 按了停止之后，“连接”按钮可以用，“发送”不能用
  97. button2.Enabled = false;
  98. button3.Enabled = false;
  99. string exitMsg = "exit"; // 要退出时，发送 exit 信息给服务器
  100. streamWriter.WriteLine(exitMsg);
  101. //刷新当前数据流中的数据
  102. streamWriter.Flush();
  103. listBox1.Items.Add("客户端关闭");
  104. ReleaseResouce();
  105. }
  106. private void button3_Click(object sender, EventArgs e)
  107. {
  108. // 启动发送线程
  109. sendThread = new Thread(new ThreadStart(SendData));
  110. sendThread.Start();
  111. }
  112. // 发送数据
  113. private void SendData()
  114. {
  115. // 发送信息不允许为空
  116. if (txtMsg.Text == "")
  117. {
  118. MessageBox.Show("发送的信息不能为空!");
  119. txtMsg.Focus();
  120. return;
  121. }
  122. try
  123. {
  124. //往当前的数据流中写入一行字符串
  125. streamWriter.WriteLine(txtMsg.Text);
  126. //刷新当前数据流中的数据
  127. streamWriter.Flush();
  128. listBox1.Items.Add("发送信息:" + txtMsg.Text);
  129. txtMsg.Text = ""; // 清空
  130. }
  131. catch (Exception exc)
  132. {
  133. MessageBox.Show(exc.Message, "ClientClient提示");
  134. }
  135. }
  136. private void Form1_Load(object sender, EventArgs e)
  137. {
  138. // 在未连接服务器前，不能发送信息和停止
  139. button2.Enabled = false;
  140. button3.Enabled = false;
  141. }
  142. // 释放资源
  143. private void ReleaseResouce()
  144. {
  145. networkStream.Close();
  146. streamReader.Close();
  147. streamWriter.Close();
  148. if (sendThread!=null&&sendThread.IsAlive)
  149. {
  150. sendThread.Abort();
  151. }
  152. if (recvThread.IsAlive)
  153. {
  154. recvThread.Abort();
  155. }
  156. if (serverThread.IsAlive)
  157. {
  158. serverThread.Abort();
  159. }
  160. myclient.Close();
  161. }
  162. private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  163. {
  164. // 如果是在连接中，则不允许关闭窗口
  165. if (button1.Enabled == false)
  166. {
  167. MessageBox.Show("请先停止连接!","ClientClient提示");
  168. e.Cancel = true;
  169. }
  170. }
  171. private void button4_Click(object sender, EventArgs e)
  172. {
  173. // 启动发送线程
  174. st = new Thread(new ThreadStart(SeData));
  175. st.Start();
  176. }
  177. // 发送数据
  178. private void SeData()
  179. {
  180. Random r = new Random();
  181. for (int i = 0; i < 10000; i++)
  182. {
  183. Thread.Sleep(400);
  184. try
  185. {
  186. //往当前的数据流中写入一行字符串
  187. streamWriter.WriteLine(r.Next(80).ToString());
  188. //刷新当前数据流中的数据
  189. streamWriter.Flush();
  190. listBox1.Items.Add("发送信息:" + r.Next(80).ToString());
  191. }
  192. catch (Exception exc)
  193. {
  194. MessageBox.Show(exc.Message, "ClientClient提示");
  195. }
  196. }
  197. }
  198. private void button5_Click(object sender, EventArgs e)
  199. {
  200. st.Abort();
  201. }
  202. }
  203. }

[csharp] view plain copy print?

  1. using System;
  2. using System.Drawing;
  3. using System.Collections;
  4. using System.ComponentModel;
  5. using System.Windows.Forms;
  6. using System.Data;
  7. using System.Net;
  8. using System.Net.Sockets;
  9. using System.Threading;
  10. using System.IO;
  11. namespace ChartTest
  12. {
  13. public partial class Form1 : Form
  14. {
  15. public Form1()
  16. {
  17. InitializeComponent();
  18. }
  19. private NetworkStream networkStream;
  20. private StreamReader streamReader;
  21. private StreamWriter streamWriter;
  22. private TcpClient myclient;
  23. private Thread recvThread;   // 接收信息线程
  24. private Thread sendThread;   // 发送信息线程
  25. private Thread serverThread;// 服务线程
  26. private Thread st;
  27. private void button1_Click(object sender, EventArgs e)
  28. {
  29. serverThread = new Thread(new ThreadStart(Connection));
  30. serverThread.Start();
  31. }
  32. private void Connection()
  33. {
  34. /*
  35. try
  36. {
  37. IPAddress ipAddress = IPAddress.Parse(txtIP.Text);
  38. Int32 port = Int32.Parse(txtPort.Text);
  39. IPEndPoint ipe = new IPEndPoint(ipAddress, port);
  40. myclient = new TcpClient();
  41. myclient.Connect(ipe);
  42. }
  43. catch
  44. {
  45. MessageBox.Show("没有连接到服务器!");
  46. return;
  47. }
  48. */
  49. try
  50. {
  51. IPAddress ipAddress = IPAddress.Parse(txtIP.Text);
  52. Int32 port = Int32.Parse(txtPort.Text);
  53. string hostName = Dns.GetHostEntry(ipAddress).HostName;
  54. myclient = new TcpClient(hostName, port);
  55. }
  56. catch
  57. {
  58. MessageBox.Show("没有连接到服务器!");
  59. return;
  60. }
  61. listBox1.Items.Add("客户端成功连接上服务器!");
  62. button1.Enabled = false;     // 连接上了，不让按“连接”按钮
  63. button2.Enabled = true;
  64. button3.Enabled = true;
  65. networkStream = myclient.GetStream();
  66. streamReader = new StreamReader(networkStream);
  67. streamWriter = new StreamWriter(networkStream);
  68. // 创建接收信息线程，并启动
  69. recvThread = new Thread(new ThreadStart(RecvData));
  70. recvThread.Start();
  71. }
  72. // 接收数据
  73. private void RecvData()
  74. {
  75. string s = streamReader.ReadLine();
  76. // 如果没接到服务器退出的消息，则继续接收信息
  77. while (s!=null&&!s.Equals("exit"))
  78. {
  79. listBox1.Items.Add("收到信息:" + s);
  80. s = streamReader.ReadLine();
  81. }
  82. // 收到服务器退出的消息，释放资源
  83. listBox1.Items.Add("服务器关闭");
  84. listBox1.Items.Add("客户端关闭");
  85. button1.Enabled = true;
  86. button2.Enabled = false;
  87. button3.Enabled = false;
  88. //      streamReader.Close();
  89. //      streamWriter.Close();
  90. //      networkStream.Close();
  91. //      myclient.Close();
  92. ReleaseResouce();
  93. }
  94. private void button2_Click(object sender, EventArgs e)
  95. {
  96. button1.Enabled = true;  // 按了停止之后，“连接”按钮可以用，“发送”不能用
  97. button2.Enabled = false;
  98. button3.Enabled = false;
  99. string exitMsg = "exit";  // 要退出时，发送 exit 信息给服务器
  100. streamWriter.WriteLine(exitMsg);
  101. //刷新当前数据流中的数据
  102. streamWriter.Flush();
  103. listBox1.Items.Add("客户端关闭");
  104. ReleaseResouce();
  105. }
  106. private void button3_Click(object sender, EventArgs e)
  107. {
  108. // 启动发送线程
  109. sendThread = new Thread(new ThreadStart(SendData));
  110. sendThread.Start();
  111. }
  112. // 发送数据
  113. private void SendData()
  114. {
  115. // 发送信息不允许为空
  116. if (txtMsg.Text == "")
  117. {
  118. MessageBox.Show("发送的信息不能为空!");
  119. txtMsg.Focus();
  120. return;
  121. }
  122. try
  123. {
  124. //往当前的数据流中写入一行字符串
  125. streamWriter.WriteLine(txtMsg.Text);
  126. //刷新当前数据流中的数据
  127. streamWriter.Flush();
  128. listBox1.Items.Add("发送信息:" + txtMsg.Text);
  129. txtMsg.Text = "";  // 清空
  130. }
  131. catch (Exception exc)
  132. {
  133. MessageBox.Show(exc.Message, "ClientClient提示");
  134. }
  135. }
  136. private void Form1_Load(object sender, EventArgs e)
  137. {
  138. // 在未连接服务器前，不能发送信息和停止
  139. button2.Enabled = false;
  140. button3.Enabled = false;
  141. }
  142. // 释放资源
  143. private void ReleaseResouce()
  144. {
  145. networkStream.Close();
  146. streamReader.Close();
  147. streamWriter.Close();
  148. if (sendThread!=null&&sendThread.IsAlive)
  149. {
  150. sendThread.Abort();
  151. }
  152. if (recvThread.IsAlive)
  153. {
  154. recvThread.Abort();
  155. }
  156. if (serverThread.IsAlive)
  157. {
  158. serverThread.Abort();
  159. }
  160. myclient.Close();
  161. }
  162. private void Form1_FormClosing(object sender, FormClosingEventArgs e)
  163. {
  164. // 如果是在连接中，则不允许关闭窗口
  165. if (button1.Enabled == false)
  166. {
  167. MessageBox.Show("请先停止连接!", "ClientClient提示");
  168. e.Cancel = true;
  169. }
  170. }
  171. private void button4_Click(object sender, EventArgs e)
  172. {
  173. // 启动发送线程
  174. st = new Thread(new ThreadStart(SeData));
  175. st.Start();
  176. }
  177. // 发送数据
  178. private void SeData()
  179. {
  180. Random r = new Random();
  181. for (int i = 0; i < 10000; i++)
  182. {
  183. Thread.Sleep(400);
  184. try
  185. {
  186. //往当前的数据流中写入一行字符串
  187. streamWriter.WriteLine(r.Next(80).ToString());
  188. //刷新当前数据流中的数据
  189. streamWriter.Flush();
  190. listBox1.Items.Add("发送信息:" + r.Next(80).ToString());
  191. }
  192. catch (Exception exc)
  193. {
  194. MessageBox.Show(exc.Message, "ClientClient提示");
  195. }
  196. }
  197. }
  198. private void button5_Click(object sender, EventArgs e)
  199. {
  200. st.Abort();
  201. }
  202. }
  203. }
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.IO;

namespace ChartTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private NetworkStream networkStream;
        private StreamReader streamReader;
        private StreamWriter streamWriter;
        private TcpClient myclient;
        private Thread recvThread;   // 接收信息线程
        private Thread sendThread;   // 发送信息线程
        private Thread serverThread;// 服务线程
        private Thread st;

        private void button1_Click(object sender, EventArgs e)
        {
            serverThread = new Thread(new ThreadStart(Connection));
            serverThread.Start();
        }

        private void Connection()
        {
            /*
            try
            {
                IPAddress ipAddress = IPAddress.Parse(txtIP.Text);
                Int32 port = Int32.Parse(txtPort.Text);
                IPEndPoint ipe = new IPEndPoint(ipAddress, port);
                myclient = new TcpClient();
                myclient.Connect(ipe);
            }
            catch
            {
                MessageBox.Show("没有连接到服务器!");
                return;
            }
            */
            try
            {
                IPAddress ipAddress = IPAddress.Parse(txtIP.Text);
                Int32 port = Int32.Parse(txtPort.Text);
                string hostName = Dns.GetHostEntry(ipAddress).HostName;
                myclient = new TcpClient(hostName, port);
            }
            catch
            {
                MessageBox.Show("没有连接到服务器!");
                return;
            }

            listBox1.Items.Add("客户端成功连接上服务器!");
            button1.Enabled = false;     // 连接上了，不让按“连接”按钮
            button2.Enabled = true;
            button3.Enabled = true;

            networkStream = myclient.GetStream();
            streamReader = new StreamReader(networkStream);
            streamWriter = new StreamWriter(networkStream);
            // 创建接收信息线程，并启动
            recvThread = new Thread(new ThreadStart(RecvData));
            recvThread.Start();
        }

        // 接收数据
        private void RecvData()
        {
            string s = streamReader.ReadLine();
            // 如果没接到服务器退出的消息，则继续接收信息
            while (s!=null&&!s.Equals("exit"))
            {
                listBox1.Items.Add("收到信息:" + s);
                s = streamReader.ReadLine();
            }
            // 收到服务器退出的消息，释放资源
            listBox1.Items.Add("服务器关闭");
            listBox1.Items.Add("客户端关闭");
            button1.Enabled = true;
            button2.Enabled = false;
            button3.Enabled = false;

            //		streamReader.Close();
            //		streamWriter.Close();
            //		networkStream.Close();
            //		myclient.Close();
            ReleaseResouce();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            button1.Enabled = true;  // 按了停止之后，“连接”按钮可以用，“发送”不能用
            button2.Enabled = false;
            button3.Enabled = false;
            string exitMsg = "exit";  // 要退出时，发送 exit 信息给服务器
            streamWriter.WriteLine(exitMsg);
            //刷新当前数据流中的数据
            streamWriter.Flush();
            listBox1.Items.Add("客户端关闭");
            ReleaseResouce();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            // 启动发送线程
            sendThread = new Thread(new ThreadStart(SendData));
            sendThread.Start();
        }

        // 发送数据
        private void SendData()
        {
            // 发送信息不允许为空
            if (txtMsg.Text == "")
            {
                MessageBox.Show("发送的信息不能为空!");
                txtMsg.Focus();
                return;
            }
            try
            {
                //往当前的数据流中写入一行字符串
                streamWriter.WriteLine(txtMsg.Text);
                //刷新当前数据流中的数据
                streamWriter.Flush();
                listBox1.Items.Add("发送信息:" + txtMsg.Text);
                txtMsg.Text = "";  // 清空
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.Message, "ClientClient提示");
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // 在未连接服务器前，不能发送信息和停止
            button2.Enabled = false;
            button3.Enabled = false;
        }

        // 释放资源
        private void ReleaseResouce()
        {
            networkStream.Close();
            streamReader.Close();
            streamWriter.Close();
            if (sendThread!=null&&sendThread.IsAlive)
            {
                sendThread.Abort();
            }
            if (recvThread.IsAlive)
            {
                recvThread.Abort();
            }
            if (serverThread.IsAlive)
            {
                serverThread.Abort();
            }
            myclient.Close();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 如果是在连接中，则不允许关闭窗口
            if (button1.Enabled == false)
            {
                MessageBox.Show("请先停止连接!", "ClientClient提示");
                e.Cancel = true;
            }
        }

        private void button4_Click(object sender, EventArgs e)
        {
            // 启动发送线程
            st = new Thread(new ThreadStart(SeData));
            st.Start();
        }

        // 发送数据
        private void SeData()
        {
            Random r = new Random();
            for (int i = 0; i < 10000; i++)
            {
                Thread.Sleep(400);
                try
                {
                    //往当前的数据流中写入一行字符串
                    streamWriter.WriteLine(r.Next(80).ToString());
                    //刷新当前数据流中的数据
                    streamWriter.Flush();
                    listBox1.Items.Add("发送信息:" + r.Next(80).ToString());
                }
                catch (Exception exc)
                {
                    MessageBox.Show(exc.Message, "ClientClient提示");
                }
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {
            st.Abort();
        }

    }
}

关于线程访问控件问题，为了偷懒，我直接屏蔽了，在Program.cs的Main()函数中加入：

[csharp] view plaincopyprint?

  1. System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls =false;

[csharp] view plain copy print?

  1. System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;
System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;

例子源码：http://download.csdn.net/detail/wangqiuyun/4502341

时间： 2024-10-16 03:36:02

Tcpclient简单聊天程序的相关文章

利用命名管道实现进程间的通信（简单聊天程序的实现）

管道的本质是一种文件,通常是指把一个进程的输出直接传递给另一个进程的输入. 命名管道(named pipe)是一种特殊的文件类型(FIFO文件),它在文件系统中以文件名的形式存在. 下面是Linux中命名管道的文件格式: 通过命令行创建命名管道可以通过mkfifo命令,函数调用如下所示: 1 #include <sys/types.h> 2 #include <sys/stat.h> 3 4 int mkfifo(const char *filename,mode_t mode);

基于html5 localStorage , web SQL, websocket的简单聊天程序

new function() { var ws = null; var connected = false; var serverUrl; var connectionStatus; var sendMessage; var connectButton; var disconnectButton; var sendButton; var open = function() { var url = serverUrl.val(); ws = new WebSocket(url); ws.onope

Linux下C语言多线程，网络通信简单聊天程序

原文:Linux下C语言多线程,网络通信简单聊天程序 功能描述:程序应用多线程技术,可是实现1对N进行网络通信聊天.但至今没想出合适的退出机制,除了用Ctr+C.出于演示目的,这里采用UNIX域协议(文件系统套接字),程序分为客户端和服务端.应用select函数来实现异步的读写操作. 先说一下服务端:首先先创建套接字,然后绑定,接下进入一个无限循环,用accept函数,接受“连接”请求,然后调用创建线程函数,创造新的线程,进入下一个循环.这样每当有一个新的“连接”被接受都会创建一个新的线程,实现

《Java项目实践》：简单聊天程序

<Java项目实践>:简单聊天程序 由于这个简单程序,还是涉及到很多的知识点,下面我们就一点一点的来完成. 我们熟悉的QQ聊天,就有一个界面,是吧,我们自己做一个简单的聊天程序,因此我们也就需要为Client写一个界面.因此,这就是我们第一步需要完成的任务. 第一步:为Client端写一个界面 完成一个界面有两种方法,一种是使用Frame对象来完成,另外一种是继承JFrame类来完成.本项目使用第二种. 第二种继承JFrame类完成的界面的程序如下: public class ChatClie

websocket实现简单聊天程序

程序的流程图: 主要代码: 服务端 app.js 先加载所需要的通信模块: var express = require('express'); var app = express(); var http = require('http').createServer(app); var io = require('socket.io').listen(http); var fs = require('fs'); 创建用户列表和消息列表: var person = []; var history =

Android 网络编程基础之简单聊天程序

前一篇讲了Android的网络编程基础,今天写了一个简单的聊天程序分享一下 首先是服务端代码: 1 package com.jiao.socketdemo; 2 3 import java.io.BufferedReader; 4 import java.io.BufferedWriter; 5 import java.io.IOException; 6 import java.io.InputStreamReader; 7 import java.io.OutputStreamWriter;

Java网络编程--简单聊天程序

背景 毕业设计前的练手,学校小比赛中的一个题目. 开发环境 Java(eclipse)+Mysql 简介 使用Java+Mysql开发以个简单的聊天工具,在本次项目中实现了: 1. 用户登录(客户端至服务器) 2. 登录服务器的用户可以公共聊天 3. 用户间可以实现私密聊天 下一次版本更新 实现同一账号只能一地登录. 界面 登录界面: 聊天主窗口: 私聊窗口:

C语言实现一个hello/hi的简单聊天程序并跟踪分析到系统调用

socket编程介绍 Socket接口是TCP/IP网络的API,Socket接口定义了许多函数或例程,可以用它们来开发TCP/IP网络上的应用程序. Socket接口设计者最先是将接口放在Unix操作系统里面的.如果了解Unix系统的输入和输出的话,就很容易了解Socket了.网络的 Socket数据传输是一种特殊的I/O,Socket也是一种文件描述符.Socket也具有一个类似于打开文件的函数调用Socket(),该函数返回一个整型的Socket描述符,随后的连接建立.数据传输等操作都是通

linux下TCP/IP实现简单聊天程序

可以在同一台电脑上运行,在一个终端上运行服务器端,在一个终端上运行客户端. 服务器端的IP地址要和本地的IP相同,并分配端口号,客户端的默认设置为本地,端口号自动分配. 服务器端: #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <sys/types.h> #include <netinet/in.h> #in