C# Thrift 实战开发 从PLC到Thrift再到客户端集成开发

About Thrift:

---

本文并不是说明Thrift设计及原理的，直接拿Thrift来开发一个Demo程序，如果想要了解Thrift的细节，可以访问官方网站：https://thrift.apache.org/ 官方的网站上除了介绍说明外，当然还有白皮书，详细的说明Thrift是干嘛用的。

简单的说，Thrift可以作为一个中间数据站，我们可以将数据丢到Thrift上，等待客户端的请求，而这个客户端可能是C#程序，当然也有可能是java程序，甚至是php，ruby，python等等，就像白皮书的介绍一样，一个灵活的，可伸缩的，多语言的服务集成。

About Demo：

---

关于本项目的意图，基于对Thrift简单的学习后，就想要拿个Demo进行练手，模拟一些实际的操作，顺便测试测试一些东西，加强自己对Thrift的理解，才能判别这个技术是否真的适合你。

大致介绍下本项目，本项目主体功能是，服务器端程序不停的读取西门子PLC进行数据更新，并将数据刷新到Thrift，客户端调用Thrift服务来访问服务器的数据，除此之外，实现一个操作，在客户端做一个按钮，点击按钮后，将一个数据（通过服务器程序中转）写入到PLC中，并返回是否写入成功的标记。

其他的功能就是测试测试连接稳定性，网络重连机制的试验。

Getting Started

---

说了那么多，赶紧开始吧，此处我的IDE时VS2017，先创建一个简单的winform项目吧。在这个解决方案里，共创建2个窗体程序，一个服务端，一个客户端，再创建一个库项目，用来生成客户端和服务器共用的代码服务。就像下面这样子

接下来我们既然要读取PLC的数据，使用Thrift技术。那么我们就要进行安装相关的插件支持，我们在NuGet界面上进行安装两个插件，Thrift和HslCommunication，对于Thrift而言，三个项目都需要安装，对于HslCommunication只需要安装到服务器：

安装HslCommunication

OK，到这里为止，我们前期的准备工作基本完成，接下来需要设计读取的数据和实现的功能，以这个为前提去设计Thrift的实现接口。

程序架构设计如下：

---

有了上述的基础设计后，接下来就是设计Thrift这一层希望提供什么样子的接口操作了，此处我们就举一些简单的例子，首先呢，设备不会只有一台，我们就假设有好多台设备，每台设备有如下参数信息：

• 设备的名称，我们采用string来存储
• 设备的唯一ID，我们也采用string来存储
• 设备的IP地址，string存储
• 设备的运行状态，允许有多个状态，int存储
• 设备的报警状态，允许组合实现32种报警，int存储，每个位对应一种报警
• 设备的温度，double数据
• 设备的压力，double数据

然后在Thrift中，我们希望公开的数据有获取单台设备的信息，也有针对报警中的统计信息。获取所有设备运行状态的json数据，所有设备报警状态的json数据，单独获取所有设备的温度数据，单独获取所有设备的压力值，最后再提供一个允许手动更改设备状态的接口，参考了官方的白皮书（地址为：https://thrift.apache.org/static/files/thrift-20070401.pdf），最终完成的Demo.thrift文件如下：

这个文件存放的目录在下面这个目录，和安装thrift的package目录一致：

接下来就是调用上图中的thrift-0.9.1.exe来生成代码了，具体方式如下：

打开电脑的cmd指令（也就是命令提示符）：

然后cd到上面的目录里去，指令为cd /d 目录，结果如下：

输入thrift-0.9.1.exe -help

ok，到这里为止，我们知道了怎么去生成C# 代码了：指令如下：thrift-0.9.1.exe --gen csharp Demo.thrift

然后我们就看到路径下多了一个文件夹

点进去后就是：

就是我们之前填写的信息生成的文件。接下来，把这两个文件添加到一开始我们创建的三个项目的Common项目中去：

重新生成Common项目，OK，到这里为止，我们前期的任务都完成了，接下来就是真正写代码的时候了。

Server Implementation

---

在Server端要做的第一件事就是添加对Common项目生成的dll组件的引用，第二件事是创建一个类，继承Common项目中的一个接口：如下：

namespace Thrift.Server
{
    public class PublicServiceHandle : ThriftInterface.PublicService.Iface
    {
        public int GetAlarmCount()
        {
            throw new NotImplementedException();
        }

        public List<MachineOne> GetAllMachineOnes()
        {
            throw new NotImplementedException();
        }

        public string GetJsonMachineAlarm()
        {
            throw new NotImplementedException();
        }

        public string GetJsonMachinePress()
        {
            throw new NotImplementedException();
        }

        public string GetJsonMachineState()
        {
            throw new NotImplementedException();
        }

        public string GetJsonMachineTemp()
        {
            throw new NotImplementedException();
        }

        public MachineOne GetMachineOne(string machineId)
        {
            throw new NotImplementedException();
        }

        public int GetRunningCount()
        {
            throw new NotImplementedException();
        }

        public bool SetMachineRunState(string machineId, int state)
        {
            throw new NotImplementedException();
        }
    }
}

　　接下来就实现这些具体代码了。

namespace Thrift.Server
{
    public class PublicServiceHandle : ThriftInterface.PublicService.Iface
    {
        #region Constructor

        /// <summary>
        /// 实例化一个对象
        /// </summary>
        public PublicServiceHandle(Func<string,int,bool> write)
        {
            // 初始化数据
            list = new List<MachineOne>()
            {
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "1#",
                    IpAddress = "192.168.1.195",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "2#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "3#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "4#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "5#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "6#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "7#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "8#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "9#",
                },
                new MachineOne()
                {
                    Name = "测试设备",
                    Id = "10#",
                },
            };

            hybirdLock = new HslCommunication.Core.SimpleHybirdLock();

            FuncWriteIntoPlc = write ?? throw new ArgumentNullException("write");
        }

        #endregion

        #region Private Member

        private List<MachineOne> list;                              // 总的数据仓库
        private HslCommunication.Core.SimpleHybirdLock hybirdLock;  // 混合同步锁，比Lock性能要高的多
        private Func<string, int, bool> FuncWriteIntoPlc;           // 写入数据的委托，最终实现在外层

        #endregion

        #region Public Method

        /// <summary>
        /// 更新一台设备的数据，这个数据最终来自PLC
        /// </summary>
        /// <param name="id"></param>
        /// <param name="content"></param>
        public void UpdateMachineOne(string id, byte[] content)
        {
            if (content == null) return;

            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].Id == id)
                {
                    byte[] buffer = new byte[4];
                    // 获取运行状态
                    Array.Copy(content, 0, buffer, 0, 4);
                    Array.Reverse(buffer);
                    list[i].RunState = BitConverter.ToInt32(buffer, 0);
                    // 获取报警状态
                    Array.Copy(content, 4, buffer, 0, 4);
                    Array.Reverse(buffer);
                    list[i].AlarmState = BitConverter.ToInt32(buffer, 0);

                    // 其实信息参照这个就行
                    break;
                }
            }
            hybirdLock.Leave();
        }

        #endregion

        #region PublicService.Interface

        /// <summary>
        /// 获取当前报警的机台数
        /// </summary>
        /// <returns></returns>
        public int GetAlarmCount()
        {
            int count = 0;
            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].AlarmState != 0) count++;
            }
            hybirdLock.Leave();
            return count;
        }

        /// <summary>
        /// 获取所有设备的所有信息，一般不建议这么做
        /// </summary>
        /// <returns></returns>
        public List<MachineOne> GetAllMachineOnes()
        {
            return new List<MachineOne>(list);
        }

        /// <summary>
        /// 获取当前所有机台的报警信息
        /// </summary>
        /// <returns></returns>
        public string GetJsonMachineAlarm()
        {
            JArray jArray = new JArray();
            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                JObject json = new JObject();
                json.Add(nameof(MachineOne.Name), new JValue(list[i].Name));
                json.Add(nameof(MachineOne.Id), new JValue(list[i].Id));
                json.Add(nameof(MachineOne.AlarmState), new JValue(list[i].AlarmState));
                jArray.Add(json);
            }
            hybirdLock.Leave();
            return jArray.ToString();
        }

        /// <summary>
        /// 获取当前所有机台的压力值
        /// </summary>
        /// <returns></returns>
        public string GetJsonMachinePress()
        {
            JArray jArray = new JArray();
            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                JObject json = new JObject();
                json.Add(nameof(MachineOne.Name), new JValue(list[i].Name));
                json.Add(nameof(MachineOne.Id), new JValue(list[i].Id));
                json.Add(nameof(MachineOne.Press), new JValue(list[i].Press));
                jArray.Add(json);
            }
            hybirdLock.Leave();
            return jArray.ToString();
        }

        /// <summary>
        /// 获取当前所有机台的状态
        /// </summary>
        /// <returns></returns>
        public string GetJsonMachineState()
        {
            JArray jArray = new JArray();
            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                JObject json = new JObject();
                json.Add(nameof(MachineOne.Name), new JValue(list[i].Name));
                json.Add(nameof(MachineOne.Id), new JValue(list[i].Id));
                json.Add(nameof(MachineOne.RunState), new JValue(list[i].RunState));
                jArray.Add(json);
            }
            hybirdLock.Leave();
            return jArray.ToString();
        }

        /// <summary>
        /// 获取当前所有机台的温度
        /// </summary>
        /// <returns></returns>
        public string GetJsonMachineTemp()
        {
            JArray jArray = new JArray();
            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                JObject json = new JObject();
                json.Add(nameof(MachineOne.Name), new JValue(list[i].Name));
                json.Add(nameof(MachineOne.Id), new JValue(list[i].Id));
                json.Add(nameof(MachineOne.Temp), new JValue(list[i].Temp));
                jArray.Add(json);
            }
            hybirdLock.Leave();
            return jArray.ToString();
        }

        /// <summary>
        /// 获取单独的一台设备信息
        /// </summary>
        /// <param name="machineId"></param>
        /// <returns></returns>
        public MachineOne GetMachineOne(string machineId)
        {
            // 这里需要不需要使用克隆对象？不太清楚，直接返回列表的对象会不会有影响？
            return list.Find(m => m.Id == machineId);
        }

        /// <summary>
        /// 获取当前正在运行的总的机台数
        /// </summary>
        /// <returns></returns>
        public int GetRunningCount()
        {
            int count = 0;
            hybirdLock.Enter();
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].RunState == 1) count++;
            }
            hybirdLock.Leave();
            return count;
        }

        /// <summary>
        /// 设置设备的运行状态
        /// </summary>
        /// <param name="machineId"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        public bool SetMachineRunState(string machineId, int state)
        {
            // 按道理说这个方法应该向PLC进行数据写入，但是具体的实现不应该在这一层
            return FuncWriteIntoPlc(machineId, state);
        }

        #endregion
    }
}

　　

　　主要功能就是实例化了一个数组，拥有十个设备，我们只有一台PLC，就模拟读取一个就行了，但数组的操作需要加同步锁，这里我们还要添加一个写入数据的功能，这个功能应该在外面实现。至此，我们可以开发真正的服务器代码了：

server上项目的form1窗口上添加两个按钮，分别为启动，和停止，都触发一个事件，然后在代码里完成Thrift的初始化：

        private PublicServiceHandle handler;
        private TServer server;

        private void userButton1_Click(object sender, EventArgs e)
        {
            new System.Threading.Thread(() =>
            {
                // 启动服务
                handler = new PublicServiceHandle(WritePlc);
                var processor = new ThriftInterface.PublicService.Processor(handler);

                TServerTransport transport = new TServerSocket(9090);

                server = new TThreadPoolServer(processor, transport);
                server.Serve();
            })
            {
                IsBackground = true
            }.Start();

            // 启动定时器去读取PLC数据
            timerReadPLC.Start();
        }
        private void userButton2_Click(object sender, EventArgs e)
        {
            // 关闭服务
            server?.Stop();
        }

　　

　　接下来需要完成读取PLC数据，并提供一个方法WritePlc实现数据的真正写入，此处由于我只有一个PLC所以，就方便实现了读写，不再区分多个设备。

        #region PLC Connection

        private SiemensTcpNet siemensTcp;                           // 和PLC的核心连接引擎
        private Timer timerReadPLC;                                 // 读取PLC的定时器

        #endregion

        private void Form1_Load(object sender, EventArgs e)
        {
            siemensTcp = new SiemensTcpNet(SiemensPLCS.S1200)
            {
                PLCIpAddress = System.Net.IPAddress.Parse("192.168.1.195")
            };

            // 连接到PLC
            siemensTcp.ConnectServer();

            timerReadPLC = new Timer();
            timerReadPLC.Interval = 1000;
            timerReadPLC.Tick += TimerReadPLC_Tick;
        }

        private void TimerReadPLC_Tick(object sender, EventArgs e)
        {
            // 每秒执行一次去读取PLC数据，此处简便操作，放在前台执行，正常逻辑应该放到后台
            HslCommunication.OperateResult<byte[]> read = siemensTcp.ReadFromPLC("M100", 24);
            if(read.IsSuccess)
            {
                handler.UpdateMachineOne("1#", read.Content);
            }
            else
            {
                // 读取失败，应该提示并记录日志，此处省略
            }
        }

        private bool WritePlc(string id, int value)
        {
            // 按道理根据不同的id写入不同的PLC，此处只有一个PLC，就直接写入到一个PLC中
            return siemensTcp.WriteIntoPLC("M100", value).IsSuccess;
        }

　　到这里为止，我们已经把服务器端的程序都已经开发完成了，已经可以生成并运行了。

Client Implementation

---

服务器端开发完成后，客户端就相对容易多了，实例化变量名，并初始化后，就可以随便使用了：

        private ThriftInterface.PublicService.Client client;

        private void Form1_Load(object sender, EventArgs e)
        {
            var transport = new TSocket("localhost", 9090);
            var protocol = new TBinaryProtocol(transport);
            client = new ThriftInterface.PublicService.Client(protocol);

            transport.Open();

            // 启动后台线程实时更新机器状态
            thread = new System.Threading.Thread(ThreadRead);
            thread.IsBackground = false;
            thread.Start();
        }

　　

增加几个按钮及显示框之后，增加一个定时读取服务器各机台状态并实时更新界面的功能：

System.Threading.Thread thread;
        private void ThreadRead()
        {
            while(true)
            {
                System.Threading.Thread.Sleep(1000);

                JArray jArray = JArray.Parse(client.GetJsonMachineState());
                int[] values = new int[10];
                // 解析开始
                for (int i = 0; i < jArray.Count; i++)
                {
                    JObject json = (JObject)jArray[i];
                    values[i] = json[nameof(ThriftInterface.MachineOne.RunState)].ToObject<int>();
                }

                if(IsHandleCreated) Invoke(new Action(() =>
                {
                    label1.Text = values[0].ToString();
                    label2.Text = values[1].ToString();
                    label3.Text = values[2].ToString();
                    label4.Text = values[3].ToString();
                    label5.Text = values[4].ToString();
                    label6.Text = values[5].ToString();
                    label7.Text = values[6].ToString();
                    label8.Text = values[7].ToString();
                    label9.Text = values[8].ToString();
                    label10.Text = values[9].ToString();
                }));
            }
        }

        private void ShowMessage(string msg)
        {
            if(textBox1.InvokeRequired)
            {
                textBox1.Invoke(new Action<string>(ShowMessage), msg);
                return;
            }

            textBox1.AppendText(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss  ") + msg + Environment.NewLine);
        }

        private void userButton1_Click(object sender, EventArgs e)
        {
            // 读取运行中机台总数
            ShowMessage(client.GetRunningCount().ToString());
        }

        private void userButton2_Click(object sender, EventArgs e)
        {
            // 读取报警中机台总数
            ShowMessage(client.GetAlarmCount().ToString());
        }

        private void userButton3_Click(object sender, EventArgs e)
        {
            // 读取所有的报警信息
            ShowMessage(client.GetJsonMachineAlarm());
        }

        private void userButton4_Click(object sender, EventArgs e)
        {
            // 读取所有的压力信息
            ShowMessage(client.GetJsonMachinePress());
        }

        private void userButton5_Click(object sender, EventArgs e)
        {
            // 读取所有的运行信息
            ShowMessage(client.GetJsonMachineState());
        }

        private void userButton6_Click(object sender, EventArgs e)
        {
            // 读取所有的温度信息
            ShowMessage(client.GetJsonMachineTemp());
        }

        private void userButton7_Click(object sender, EventArgs e)
        {
            // 读取指定机台信息
            ThriftInterface.MachineOne machine = client.GetMachineOne("1#");
        }

        private void userButton8_Click(object sender, EventArgs e)
        {
            // 强制机台启动
            if(client.SetMachineRunState("1#",1))
            {
                ShowMessage("写入成功！");
            }
            else
            {
                ShowMessage("写入失败！");
            }
        }

        private void userButton10_Click(object sender, EventArgs e)
        {
            // 强制机台停止
            if(client.SetMachineRunState("1#",0))
            {
                ShowMessage("写入成功！");
            }
            else
            {
                ShowMessage("写入失败！");
            }
        }

        private void userButton9_Click(object sender, EventArgs e)
        {
            // 用于高频多线程压力测试
            new System.Threading.Thread(ThreadReadManyTimes) { IsBackground = true, Name = "1" }.Start();
            new System.Threading.Thread(ThreadReadManyTimes) { IsBackground = true, Name = "2" }.Start();
            new System.Threading.Thread(ThreadReadManyTimes) { IsBackground = true, Name = "3" }.Start();
        }

        private void ThreadReadManyTimes()
        {
            for (int i = 0; i < 1000; i++)
            {
                client.GetRunningCount();
            }

            ShowMessage(System.Threading.Thread.CurrentThread.Name + "完成！");
        }

　　

所有的代码都已经写完，接下来就是最终演示了：

但是在三条线程的压力测试中，会出现异常，内部同步机制可能没有做好，不知道什么原因，如果你知道，本人非常感谢！

本项目的github地址：https://github.com/dathlin/ThriftDemo