将之前的通信代码，以winform界面的形式写出来

winform应用程序，与控制台程序的代码没有太大的区别，最大的不同是将代码拆分成一个个小块，即一个个的方法，这样可以通过一个个的控件（按钮button等）去触发事件（方法）。 但是我感觉，不好的是，winform程序容易因为点击按钮的顺序，次数的不同，使程序出错，所以要多多的用try-catch。

客户端代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace WindowsForms_客户端
{
    public partial class Form1 : Form
    {

        byte[] data;
        string stringData;
        //创建服务器端IPEndPoint对象
        IPEndPoint Ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 125);
        Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 与服务器建立连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonConnect_Click(object sender, EventArgs e)
        {
            try
            {
                server.Connect(Ipep);
                textState.AppendText("连接成功
");
            }
            catch
            {
                textState.AppendText("连接服务器失败
");
                MessageBox.Show("请先启动服务器，再启动客户端");
                return;
            }
            Thread th = new Thread(Receive);
            th.IsBackground = true;
            th.Start();
        }

        /// <summary>
        /// 断开与服务器的连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonBreak_Click(object sender, EventArgs e)
        {
            server.Shutdown(SocketShutdown.Both);
            server.Close();
            textState.AppendText("断开与服务器的连接
");
        }

        

        /// <summary>
        /// 接收消息的方法  用的方法是ReceiveVarMessage 接收变长消息
        /// </summary>
        void Receive()
        {
            while (true)
            {
                data = ReceiveVarMessage(server);
                if (data.Length == 0)
                {
                    break;
                }
                stringData = Encoding.UTF8.GetString(data, 0, data.Length);
                textReceive.AppendText(stringData + "
");
            }


            //while (true)
            //{
            //    //接收数据
            //    int receive = server.Receive(data);//receive是接收到的数据的长度 所以是int型  接收到的信息，存在data这个byte字节数组中
            //    if (receive == 0)
            //    {
            //        break;
            //    }
            //    stringData = Encoding.UTF8.GetString(data, 0, receive);
            //    textReceive.AppendText(stringData + "
");
            //}
        }

        /// <summary>
        /// 跨线程访问
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
            textKp.Text = "0.4";
            textKi.Text = "0.53";
            textKd.Text = "0.1";
            textKd.Focus();

        }

        /// <summary>
        /// 发送消息到服务器端
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonSend_Click(object sender, EventArgs e)
        {
            string str = textSend.Text;
            data = System.Text.Encoding.UTF8.GetBytes(str);
            SendVarMessage(server, data);
        }

        private void textReceive_TextChanged(object sender, EventArgs e)
        {

        }

        int i = 0;
        /// <summary>
        /// 客户端发送设定速度值 给服务器端
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            string speed = textSetspeed.Text;
            try
            {
                double dSpeed = Convert.ToDouble(speed);
                data = System.Text.Encoding.UTF8.GetBytes(speed);
                textSend.AppendText("第"+(i+1)+"次发送的设定速度值是"+speed+"
");
                SendVarMessage(server, data);
                //server.Send(data);
                i++;
                textSetspeed.Clear();
                textSetspeed.Focus();
            }
            catch
            {
                MessageBox.Show("输入速度设定值不正确，请重新输入");
                textSend.AppendText(speed + "
");
                textSetspeed.Clear();
                textSetspeed.Focus();
            }
        }

        /// <summary>
        /// 发送变长消息方法
        /// </summary>
        /// <param name="s"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        private static void SendVarMessage(Socket s, byte[] msg)
        {
            int offset = 0;
            int sent;
            int size = msg.Length;
            int dataleft = size;
            byte[] msgsize = new byte[2];

            //将消息的尺寸从整型转换成可以发送的字节型
            //因为int型是占4个字节 所以msgsize是4个字节 后边是空字节
            msgsize = BitConverter.GetBytes(size);

            //发送消息的长度信息
            //之前总是乱码出错 客户端接收到的欢迎消息前两个字节是空 后边的两个字符er传送到第二次接收的字节数组中
            //因此将er字符转换为int出错  这是因为之前在Send代码中，是将msgsize整个字节数组发送给客户端 所以导致第3 4个空格也发送
            //导致发送的信息混乱 这两个空格使发送的信息都往后挪了两个位置  从而乱码
            sent = s.Send(msgsize, 0, 2, SocketFlags.None);
            while (dataleft > 0)
            {
                int sent2 = s.Send(msg, offset, dataleft, SocketFlags.None);
                //设置偏移量
                offset += sent2;
                dataleft -= sent2;
            }
        }

        /// <summary>
        /// 接收变长消息方法
        /// </summary>
        /// <param name="s"></param>
        /// <returns>接收到的信息</returns>
        private static byte[] ReceiveVarMessage(Socket s)//方法的返回值是字节数组 byte[] 存放的是接受到的信息
        {
            int offset = 0;
            int recv;
            byte[] msgsize = new byte[2];

            //接收2个字节大小的长度信息
            recv = s.Receive(msgsize, 0, 2, 0);

            //将字节数组的消息长度转换为整型
            int size = BitConverter.ToInt16(msgsize, 0);
            int dataleft = size;
            byte[] msg = new byte[size];
            while (dataleft > 0)
            {
                //接收数据
                recv = s.Receive(msg, offset, dataleft, 0);
                if (recv == 0)
                {
                    break;
                }
                offset += recv;
                dataleft -= recv;
            }
            return msg;
        }

        ///// <summary>
        ///// 将kp参数的设置，发送给客户端     这里还没有客户端在线修改kp ki kd参数的功能 
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        private void buttonChange_Click(object sender, EventArgs e)
        {
        //    data = System.Text.Encoding.UTF8.GetBytes(textKp.Text);
        //    SendVarMessage(server, data);

        //    //data = System.Text.Encoding.UTF8.GetBytes(textKi.Text);
        //    //SendVarMessage(server, data);

        //    //data = System.Text.Encoding.UTF8.GetBytes(textKd.Text);
        //    //SendVarMessage(server, data);
        }

        ///// <summary>
        ///// 修改ki参数
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        private void buttonChangeki_Click(object sender, EventArgs e)
        {
        //    data = System.Text.Encoding.UTF8.GetBytes(textKi.Text);
        //    SendVarMessage(server, data);
        }

        ///// <summary>
        ///// 修改kd参数
        ///// </summary>
        ///// <param name="sender"></param>
        ///// <param name="e"></param>
        private void buttonChangekd_Click(object sender, EventArgs e)
        {
        //    data = System.Text.Encoding.UTF8.GetBytes(textKd.Text);
        //    SendVarMessage(server, data);
        }


    }
}

服务器端代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Collections;

namespace WindowsForms_服务器端
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        double[] nums = new double[3];//存储3个偏差值e(k) e(k-1) e(k-2)
        double actual = 0;
        double set = 0;
        double kp;
        double ki;
        double kd;
        //定义一个空字节数组date作为数据缓冲区，用于缓冲流入和流出的信息
        byte[] date;
        static Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        static Socket client;
        ArrayList list = new ArrayList();//存储客户端发来的速度设定值
        ArrayList listOut = new ArrayList();//存储PID计算的实际速度值
        Dictionary<string, Socket> dicSocket = new Dictionary<string, Socket>();//创建键值对，存储套接字的ip地址等信息

        Thread thConnect;

        /// <summary>
        /// 建立与客户端的连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonConnect_Click(object sender, EventArgs e)
        {
            try
            {
                IPEndPoint Ipep = new IPEndPoint(IPAddress.Any, 125);//指定地址和端口号
                newsock.Bind(Ipep);
                newsock.Listen(10);//置于监听状态
                textState.Text = "等待客户端的连接
";
                thConnect = new Thread(Connect);
                thConnect.IsBackground = true;
                thConnect.Start();
                //Receive();
            }
            catch
            { }
        }

        /// <summary>
        /// 不断接收从客户端发来消息的方法
        /// </summary>
        void Receive()
        {
            try
            {
                while (true)
                {
                    date = ReceiveVarMessage(client);
                    if (date.Length == 0)
                    {
                        break;
                    }
                    string str = Encoding.UTF8.GetString(date, 0, date.Length);
                    list.Add(str);
                    textReceive.AppendText(str + "
");
                }
            }
            catch
            { }
        }

        /// <summary>
        /// 服务器端与客户端连接的方法  使一个服务器可以与多个客户端连接
        /// </summary>
        private void Connect()
        {
            //接收来自客户端的接入尝试连接，并返回连接客户端的ip地址
            while (true)
            {
                client = newsock.Accept();
                IPEndPoint clientep = (IPEndPoint)client.RemoteEndPoint;
                //返回客户端的ip地址和端口号
                textState.AppendText("与" + clientep.Address + "在" + clientep.Port + "端口连接
");
                dicSocket.Add(clientep.ToString(), client);//将连接的客户端的IP地址添加在键值对集合中
                comboBox.Items.Add(clientep);//将客户端的IP地址显示在下拉栏中
                //Receive();
                Thread thReceive = new Thread(Receive);//创建一个新线程 执行Receive()方法
                thReceive.IsBackground = true;
                thReceive.Start();
            }
        }

        /// <summary>
        /// 发送消息给客户端 需自己选择已连接的其中一个客户端
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonSend_Click(object sender, EventArgs e)
        {
            try
            {
                string str = textSend.Text;
                date = System.Text.Encoding.UTF8.GetBytes(str); //以字节数组的形式 将欢迎信息发送给客户端 注意发送与接收要用相同的编码格式UTF8 否则会乱码
                try
                {
                    string ip = comboBox.SelectedItem.ToString();
                    SendVarMessage(dicSocket[ip], date);
                }
                catch
                {
                    MessageBox.Show("发送失败，请确认已选择一个客户端");
                }
            }
            catch
            { }
        }


        /// <summary>
        /// 断开与客户端的连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonBreak_Click(object sender, EventArgs e)
        {
            try
            {
                client.Close();
                newsock.Close();
                textState.AppendText("断开连接
");
            }
            catch { }
        }

        /// <summary>
        /// 跨线程访问
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        private void textState_TextChanged(object sender, EventArgs e)
        {

        }

        private void textReceive_TextChanged(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// 开始进行PID计算
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            //Thread thKp = new Thread(GetKp);
            //thKp.IsBackground = true;
            //thKp.Start();
            ////date=ReceiveVarMessage(client);
            ////string strKp = Encoding.UTF8.GetString(date,0,date.Length);
            ////kp = Convert.ToDouble(strKp);

            //Thread thKi = new Thread(GetKi);
            //thKi.IsBackground = true;
            //thKi.Start();
            ////date = ReceiveVarMessage(client);
            ////string strKi = Encoding.UTF8.GetString(date, 0, date.Length);
            ////ki = Convert.ToDouble(strKi);

            //Thread thKd = new Thread(GetKd);
            //thKd.IsBackground = true;
            //thKd.Start();
            ////date = ReceiveVarMessage(client);
            ////string strKd = Encoding.UTF8.GetString(date);
            ////kd = Convert.ToDouble(strKd);

            int n = list.Count;
            int i = 0;
            while (i < n)
            {
                set = double.Parse(list[i].ToString());
                nums[0] = set - actual;
                double increase = 0.4* (nums[0] - nums[1]) + 0.53 * nums[0] + 0.1 * (nums[0] - 2 * nums[1] + nums[2]);
                actual += increase;
                listOut.Add(actual);//将每次的实际速度值  添加到集合中
                textActualspeed.AppendText("第" + (i + 1) + "次的实际输出速度是" + actual + "
"); //输出实际的速度值 成功！
                nums[1] = nums[0];
                nums[2] = nums[1];
                i++;
            }
        }

        ///// <summary>
        ///// 得到客户端传来的Kp参数
        ///// </summary>
        //private void GetKp()
        //{
        //    date = ReceiveVarMessage(client);
        //    string strKp = Encoding.UTF8.GetString(date, 0, date.Length);
        //    kp = Convert.ToDouble(strKp);
        //}

        ///// <summary>
        ///// 得到客户端传来的Ki参数
        ///// </summary>
        //private void GetKi()
        //{
        //    date = ReceiveVarMessage(client);
        //    string strKi = Encoding.UTF8.GetString(date, 0, date.Length);
        //    ki = Convert.ToDouble(strKi);
        //}

        ///// <summary>
        ///// 得到客户端传来的Kd参数
        ///// </summary>
        //private void GetKd()
        //{
        //    date = ReceiveVarMessage(client);
        //    string strKd = Encoding.UTF8.GetString(date, 0, date.Length);
        //    kd = Convert.ToDouble(strKd);
        //}

        /// <summary>
        /// 发送变长消息方法
        /// </summary>
        /// <param name="s"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        private static void SendVarMessage(Socket s, byte[] msg)
        {
            int offset = 0;
            int sent;
            int size = msg.Length;
            int dataleft = size;
            byte[] msgsize = new byte[2];

            //将消息的尺寸从整型转换成可以发送的字节型
            //因为int型是占4个字节 所以msgsize是4个字节 后边是空字节
            msgsize = BitConverter.GetBytes(size);

            //发送消息的长度信息
            //之前总是乱码出错 客户端接收到的欢迎消息前两个字节是空 后边的两个字符er传送到第二次接收的字节数组中
            //因此将er字符转换为int出错  这是因为之前在Send代码中，是将msgsize整个字节数组发送给客户端 所以导致第3 4个空格也发送
            //导致发送的信息混乱 这两个空格使发送的信息都往后挪了两个位置  从而乱码
            sent = s.Send(msgsize, 0, 2, SocketFlags.None);
            while (dataleft > 0)
            {
                int sent2 = s.Send(msg, offset, dataleft, SocketFlags.None);
                //设置偏移量
                offset += sent2;
                dataleft -= sent2;
            }
            //return dataleft;
        }

        /// <summary>
        /// 接收变长消息方法
        /// </summary>
        /// <param name="s"></param>
        /// <returns>接收到的信息</returns>
        private static byte[] ReceiveVarMessage(object o)//方法的返回值是字节数组 byte[] 存放的是接受到的信息
        {
            Socket s = o as Socket;
            int offset = 0;
            int recv;
            byte[] msgsize = new byte[2];

            //接收2个字节大小的长度信息
            recv = s.Receive(msgsize, 0, 2, 0);

            //将字节数组的消息长度转换为整型
            int size = BitConverter.ToInt16(msgsize, 0);
            int dataleft = size;
            byte[] msg = new byte[size];
            while (dataleft > 0)
            {
                //接收数据
                recv = s.Receive(msg, offset, dataleft, 0);
                if (recv == 0)
                {
                    break;
                }
                offset += recv;
                dataleft -= recv;
            }
            return msg;
        }
    }
}

这里还没有实现客户端在线修改kp ki kd参数的功能，pid计算用的参数是初始给定的定值。

接收消息Receive部分的代码，是不断的接收对方发送来的消息，不能分辨其发送的是kp ki参数的设定值（double型），还是速度设定值setSpeed（int或double型），还是欢迎消息welcome to the server（string型），所以，应该需要标记符，放在要发送的消息中，如：字节数组第一位是0，表示发送的是速度设定值，第一位为2表示kp参数设定值……