[网络协议]超级消息转换器

之前实现的检验虚拟盒子虽然实现了串口转TCP功能，但是缺乏设计，表现为设计太僵硬，只能固定两三种转换模式。而且随着转换增加复杂度太大。比如要实现某些仪器TCP不能跨网站做TCP直接跳板就难度大大增加。

虚拟盒子体现为代码力，这次体现为设计力。

源码

虚拟盒子如下：

新效果-TCP跳转示例

其他测试

为了解决设计不足导致的扩展困难，全新设计了超级转换器，分享初版代码。这次抽取了转换器接口，和提取了委托。实现为一个dll，方便其他exe快速引入。

拿串口端来说，本质就是1.监控串口发来的消息，然后转发出去。2.把其他端发来的消息推送到串口。

拿tcp端来说，本质就是1.监控tcp端发来的消息，然后转发出去。2.把其他端发来的消息转发给tcp。

默认实现了串口、tcp服务端、tcp客户端、udp服务端、udp客户端。也可以实现接口来实现读写文本，调用webservice等，只要是需要转发消息的都可。

抽取接口如下（所有的消息实现端实现该接口）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MessageSwitch
{
    ///<summary  NoteObject="Class">
    /// [功能描述:消息转换器接口，所有消息用户控件实现该接口，符合该接口的实现可以配置到转接中心两端] <para/>
    /// [创建者:zlz] <para/>
    /// [创建时间:2021年11月13日] <para/>
    ///<说明>
    ///  [说明:消息转换器接口，所有消息用户控件实现该接口，符合该接口的实现可以配置到转接中心两端]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public interface IMessageSwitch
    {
        /// <summary>
        /// 得到实现类型的名字，供写日志用
        /// </summary>
        /// <returns></returns>
        string GetTypeName();

        /// <summary>
        /// 得到配置串
        /// </summary>
        /// <returns>配置串</returns>
        string GetConfig();


        /// <summary>
        /// 设置配置,供主程序把配置设置上去
        /// </summary>
        /// <param name="confStr">配置串</param>
        /// <returns>是否成功</returns>
        bool SetConfig(string confStr);

        /// <summary>
        /// 供转换中心设置回调方法给消息实现
        /// </summary>
        /// <param name="push">推送器</param>
        /// <param name="type">推送端来源</param>
        /// <param name="log">写日志委托</param>
        /// <returns>是否成功</returns>
        bool SetPushDelegate(PushMessageToSwitch push, SwitchType type, WriteLog log);


        /// <summary>
        /// 启动
        /// </summary>
        /// <returns>是否成功</returns>
        bool Start();

        /// <summary>
        /// 停止
        /// </summary>
        /// <returns>是否成功</returns>
        bool Stop();

        /// <summary>
        /// 提供转换中心给改接口推送消息
        /// </summary>
        /// <param name="msgByteArr">消息的比特数组</param>
        /// <returns>是否成功</returns>
        bool SendMessage(byte[] msgByteArr);

        /// <summary>
        /// 得到该对象的反射配置串，供主程序按配置加载，格式：类全名,动态库名字(不带dll)
        /// </summary>
        /// <returns></returns>
        string GetReflectStr();

    }
}

转换器及委托实现转换逻辑

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace MessageSwitch
{
    /// <summary>
    /// 交换类型，标识消息实现所在的端
    /// </summary>
    public enum SwitchType
    {
        In,
        Out
    }

    /// <summary>
    /// 把收到的消息推送到转换器委托，所有消息接口通过该委托把消息推送到转换中心
    /// </summary>
    /// <param name="msgByteArr">消息</param>
    /// <param name="type">推送端来源</param>
    /// <returns>是否成功</returns>
    public delegate bool PushMessageToSwitch(byte[] msgByteArr,SwitchType type);

    /// <summary>
    /// 写日志委托
    /// </summary>
    /// <param name="msg">消息</param>
    public delegate void WriteLog(string msg);

    /// <summary>
    /// 添加转换器
    /// </summary>
    /// <param name="sw"></param>
    public delegate void AddMessageSwitch(IMessageSwitch sw,SwitchType type);


    ///<summary  NoteObject="Class">
    /// [功能描述:消息转换器核心，实现消息转换] <para/>
    /// [创建者:zlz] <para/>
    /// [创建时间:2021年11月13日] <para/>
    ///<说明>
    ///  [说明:消息转换器核心，实现消息转换]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public class SwitchMian
    {
        /// <summary>
        /// 输入端接口集合
        /// </summary>
        private List<IMessageSwitch> inList = new List<IMessageSwitch>();

        /// <summary>
        /// 输出端消息集合
        /// </summary>
        private List<IMessageSwitch> outList = new List<IMessageSwitch>();

        /// <summary>
        /// 推送消息委托
        /// </summary>
        private PushMessageToSwitch PushMessage;

        /// <summary>
        /// 写日志委托
        /// </summary>
        private WriteLog log;


        /// <summary>
        /// 构造函数
        /// </summary>
        public SwitchMian(WriteLog logW)
        {
            PushMessage = new PushMessageToSwitch(PushMessageToSwitchDo);
            log = logW;
        }

        /// <summary>
        /// 接收推过来的消息
        /// </summary>
        /// <param name="msgByteArr">消息</param>
        /// <param name="type">来源</param>
        /// <returns>是否成功</returns>
        private bool PushMessageToSwitchDo(byte[] msgByteArr, SwitchType type)
        {
            string lineStr = System.Text.Encoding.Default.GetString(msgByteArr);
            //处理不可见字符为可见字符
            lineStr = Util.DealNotSeeToSeeChar(lineStr);
            //消息来自In就给所有Out推送
            if (type == SwitchType.In)
            {
                if (outList != null && outList.Count > 0)
                {
                    foreach (IMessageSwitch s in outList)
                    {
                        if (log != null)
                        {
                            log("输入->输出"+lineStr);
                        }
                        s.SendMessage(msgByteArr);
                    }
                }
            }
            //消息来自Out就给所有In推送
            if (type == SwitchType.Out)
            {
                if (inList != null && inList.Count > 0)
                {
                    foreach (IMessageSwitch s in inList)
                    {
                        if (log != null)
                        {
                            log("输出->输入" + lineStr);
                        }
                        s.SendMessage(msgByteArr);
                    }
                }
            }
            return true;
        }

        

        /// <summary>
        /// 添加消息实现到输入端
        /// </summary>
        /// <param name="obj">消息实现</param>
        public void AddToIn(IMessageSwitch obj)
        {
            if (log != null)
            {
                log(obj.GetTypeName()+"加入输入端");
            }
            obj.SetPushDelegate(PushMessage, SwitchType.In,log);
            inList.Add(obj);
        }

        /// <summary>
        /// 添加消息实现到输出端
        /// </summary>
        /// <param name="obj">消息实现</param>
        public void AddToOut(IMessageSwitch obj)
        {
            if (log != null)
            {
                log(obj.GetTypeName() + "加入输出端");
            }
            obj.SetPushDelegate(PushMessage, SwitchType.Out,log);
            outList.Add(obj);
        }

        /// <summary>
        /// 得到配置
        /// </summary>
        /// <returns>配置串</returns>
        public string  GetConfig()
        {
            List<ConfDto> confList = new List<ConfDto>();
            if (inList != null && inList.Count > 0)
            {
                foreach (IMessageSwitch s in inList)
                {
                    if (log != null)
                    {
                        log("获取:" + s.GetTypeName()+"配置");
                    }
                    ConfDto dto = new ConfDto();
                    dto.ConfStr = s.GetConfig();
                    dto.ReflectStr = s.GetReflectStr();
                    dto.Type = SwitchType.In;
                    confList.Add(dto);
                }
            }
            if (outList != null && outList.Count > 0)
            {
                foreach (IMessageSwitch s in outList)
                {
                    if (log != null)
                    {
                        log("获取:" + s.GetTypeName() + "配置");
                    }
                    ConfDto dto = new ConfDto();
                    dto.ConfStr = s.GetConfig();
                    dto.ReflectStr = s.GetReflectStr();
                    dto.Type = SwitchType.Out;
                    confList.Add(dto);
                }
            }
            return Util.Serializer(confList.GetType(), confList);
        }

        /// <summary>
        /// 设置配置
        /// </summary>
        /// <param name="confStr">配置串</param>
        /// <param name="addSw">回调方法</param>
        public void LoadConfig(string confStr,AddMessageSwitch addSw)
        {
            List<ConfDto> confList = Util.XmlDeserialize<List<ConfDto>>(confStr, Encoding.Default);
            if (confList != null && confList.Count > 0)
            {
                foreach (var v in confList)
                {
                    if (v.Type == SwitchType.In)
                    {
                        object obj = GetObjectByReflectStr(v.ReflectStr);
                        if (obj != null)
                        {
                            IMessageSwitch swi = obj as IMessageSwitch;
                            if (swi != null)
                            {
                                swi.SetConfig(v.ConfStr);
                                if (log != null)
                                {
                                    log("载入:" + swi.GetTypeName() + "对象到输入端");
                                }
                                AddToIn(swi);
                                //执行回调
                                if (addSw != null)
                                {
                                    addSw(swi, SwitchType.In);
                                }
                            }
                        }
                    }
                    if (v.Type == SwitchType.Out)
                    {
                        object obj = GetObjectByReflectStr(v.ReflectStr);
                        if (obj != null)
                        {
                            IMessageSwitch swi = obj as IMessageSwitch;
                            if (swi != null)
                            {
                                swi.SetConfig(v.ConfStr);
                                if (log != null)
                                {
                                    log("载入:" + swi.GetTypeName() + "对象到输出端");
                                }
                                AddToOut(swi);
                                //执行回调
                                if (addSw != null)
                                {
                                    addSw(swi, SwitchType.Out);
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 通过反射串得到对象
        /// </summary>
        /// <param name="reflectStr">反射串</param>
        /// <returns></returns>
        public object GetObjectByReflectStr(string reflectStr)
        {
            try
            {
                if (log != null)
                {
                    log("准备解析处理对象：" + reflectStr);
                }
                string[] strArr = reflectStr.Replace(" ", "").Split(',');
                if (strArr.Length < 2)
                {
                    if (log != null)
                    {
                        log("配置的处理对象错误，请采用类全名,动态库名");
                    }
                }
                if ((strArr.Length) < 2)
                {
                    return null;
                }
                string path = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory,strArr[1]);
                if (!path.Contains(".dll"))
                {
                    path = path + ".dll";
                }
                Assembly assembly = Assembly.LoadFile(path);
                object obj = assembly.CreateInstance(strArr[0], false);
                if (log != null)
                {
                    log("解析处理对象：" + reflectStr + "成功");
                }
                return obj;
            }
            catch (Exception ex)
            {
                if (log != null)
                {
                    log("解析处理对象出错：" + ex.Message);
                }
                return null;
            }
        }

        /// <summary>
        /// 开启转换器
        /// </summary>
        public void StartSwitch()
        {
            if (inList != null && inList.Count > 0)
            {
                foreach (IMessageSwitch s in inList)
                {
                    if (log != null)
                    {
                        log("开启输输入端:" + s.GetTypeName());
                    }
                    s.Start();
                }
            }
            if (outList != null && outList.Count > 0)
            {
                foreach (IMessageSwitch s in outList)
                {
                    if (log != null)
                    {
                        log("开启输出端:" + s.GetTypeName());
                    }
                    s.Start();
                }
            }
        }

        /// <summary>
        /// 停止转换器
        /// </summary>
        public void StopSwitch()
        {
            if (inList != null && inList.Count > 0)
            {
                foreach (IMessageSwitch s in inList)
                {
                    if (log != null)
                    {
                        log("停止输输入端:" + s.GetTypeName());
                    }
                    s.Stop();
                }
            }
            if (outList != null && outList.Count > 0)
            {
                foreach (IMessageSwitch s in outList)
                {
                    if (log != null)
                    {
                        log("停止输出端:" + s.GetTypeName());
                    }
                    s.Stop();
                }
            }
        }
    }

    /// <summary>
    /// 配置实体
    /// </summary>
    public class ConfDto
    {
        /// <summary>
        /// 反射用的串
        /// </summary>
        public string ReflectStr
        {
            get;
            set;
        }

        /// <summary>
        /// 类型
        /// </summary>
        public SwitchType Type
        {
            get;
            set;
        }

        /// <summary>
        /// 配置串
        /// </summary>
        public string ConfStr
        {
            get;
            set;
        }
    }

}

主转换器用户控件，主转换器界面实现

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

namespace MessageSwitch
{
    public partial class SwitchMainUI : UserControl
    {
        /// <summary>
        /// 转换器主对象
        /// </summary>
        private SwitchMian switchMian =null;

        /// <summary>
        /// 输入控件顶部
        /// </summary>
        private int InTop = 0;

        /// <summary>
        /// 输出控件顶部
        /// </summary>
        private int OutTop = 0;

        public SwitchMainUI()
        {
            InitializeComponent();
        }


        /// <summary>
        /// 添加输入端
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAddIn_Click(object sender, EventArgs e)
        {
            object reflectObj = cmbType.SelectedValue;
            if (reflectObj == null)
            {
                MessageBox.Show("请选择要添加的类型！", "提示");
                return;
            }
            object swiObj = switchMian.GetObjectByReflectStr(reflectObj.ToString());
            IMessageSwitch swi = swiObj as IMessageSwitch;
            UserControl swiu = swiObj as UserControl;
            swiu.Top = InTop;
            InTop += swiu.Height+10;
            tabPageIn.Controls.Add(swiu);
            switchMian.AddToIn(swi);
        }

        /// <summary>
        /// 添加输出端
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAddOut_Click(object sender, EventArgs e)
        {
            object reflectObj = cmbType.SelectedValue;
            if (reflectObj == null)
            {
                MessageBox.Show("请选择要添加的类型！", "提示");
                return;
            }
            object swiObj = switchMian.GetObjectByReflectStr(reflectObj.ToString());
            IMessageSwitch swi = swiObj as IMessageSwitch;
            UserControl swiu = swiObj as UserControl;
            swiu.Top = OutTop;
            OutTop += swiu.Height+10;
            tabPageOut.Controls.Add(swiu);
            switchMian.AddToOut(swi);
        }

        /// <summary>
        /// 保存配置
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSaveConfig_Click(object sender, EventArgs e)
        {
            string confStr=switchMian.GetConfig();
            string path = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "SwitchMian.conf");
            Util.WriteTxt(path, confStr);
            MessageBox.Show("配置保存在SwitchMian.conf！", "提示");
        }

        /// <summary>
        /// 启动转换
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, EventArgs e)
        {
            switchMian.StartSwitch();
        }

        /// <summary>
        /// 停止转换
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStop_Click(object sender, EventArgs e)
        {
            switchMian.StopSwitch();
        }

        /// <summary>
        /// 加载方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SwitchMainUI_Load(object sender, EventArgs e)
        {
            switchMian = new SwitchMian(new WriteLog(WritLogs));
            string path = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "SwitchType.conf");
            string TypeConfStr = Util.ReadTxt(path);
            if (TypeConfStr != "")
            {
                TypeConfStr = TypeConfStr.Replace("\r\n",(char)0+"");
                string[] arr = TypeConfStr.Split((char)0);
                List<CmbDto> cmbList = new List<CmbDto>();
                foreach(string s in arr)
                {
                    if (s == "")
                    {
                        continue;
                    }
                    string[] arrOne = s.Split('^');
                    if (arrOne.Length != 2)
                    {
                        MessageBox.Show("配置格式不对！格式：名称^反射串", "提示");
                    }
                    else
                    {
                        CmbDto dto = new CmbDto();
                        dto.Name = arrOne[0];
                        dto.ReflectStr = arrOne[1];
                        cmbList.Add(dto);
                    }
                }
                cmbType.DataSource = cmbList;
                cmbType.ValueMember = "ReflectStr";
                cmbType.DisplayMember = "Name";
            }
            string pathConf = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "SwitchMian.conf");
            if(System.IO.File.Exists(pathConf))
            {
                string conf=Util.ReadTxt(pathConf);
                switchMian.LoadConfig(conf, new AddMessageSwitch(AddMessageSwitchDo));
                switchMian.StartSwitch();
            }
        }

        /// <summary>
        /// 添加转换器
        /// </summary>
        /// <param name="sw"></param>
        public  void AddMessageSwitchDo(IMessageSwitch sw,SwitchType type)
        {
            UserControl swiu = sw as UserControl;
            if (type == SwitchType.In)
            {
                swiu.Top = InTop;
                InTop += swiu.Height + 10;
                tabPageIn.Controls.Add(swiu);
            }
            if (type == SwitchType.Out)
            {
                swiu.Top = OutTop;
                OutTop += swiu.Height + 10;
                tabPageOut.Controls.Add(swiu);
            }
        }


        /// <summary>
        /// 写日志
        /// </summary>
        /// <param name="log"></param>
        private void WritLogs(string log)
        {
            object [] para=new object[1];
            para[0]=log;
            this.Invoke(new WriteLog(WritLogsDo), para);
        }

        /// <summary>
        /// 写日志
        /// </summary>
        /// <param name="log"></param>
        private void WritLogsDo(string log)
        {
            txtInfo.Text += DateTime.Now.ToString("HH:mm:ss ")+ log + "\n";
        }

        /// <summary>
        /// 下拉框实体
        /// </summary>
        class CmbDto
        {
            /// <summary>
            /// 显示名称
            /// </summary>
            public string Name
            {
                get;
                set;
            }

            /// <summary>
            /// 反射串
            /// </summary>
            public string ReflectStr
            {
                get;
                set;
            }
        }
    }
}

串口实现示例，对接串口消息

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO.Ports;

namespace MessageSwitch
{
    ///<summary  NoteObject="Class">
    /// [功能描述:串口实现] <para/>
    /// [创建者:zlz] <para/>
    /// [创建时间:2021年11月13日] <para/>
    ///<说明>
    ///  [说明:串口实现]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public partial class UCSerialPort : UserControl, IMessageSwitch
    {
        /// <summary>
        /// 串口对象
        /// </summary>
        private SerialPort comm = new SerialPort();

        /// <summary>
        /// 推送器
        /// </summary>
        private PushMessageToSwitch pushToSwitch;

        /// <summary>
        /// 类型
        /// </summary>
        SwitchType type;

        /// <summary>
        /// 写日志委托
        /// </summary>
        private WriteLog log;

        public UCSerialPort()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 得到类型名字
        /// </summary>
        /// <returns></returns>
        public string GetTypeName()
        {
            return "串口";
        }

        /// <summary>
        /// 得到配置
        /// </summary>
        /// <returns></returns>
        public string GetConfig()
        {
            string confStr = cmbPortName.Text + "#" + cmbBaudrate.Text + "#" + cmbDataBits.Text + "#" + cmbStopBits.Text + "#" + cmbParity.Text;
            return confStr;
        }

        /// <summary>
        /// 设置配置
        /// </summary>
        /// <param name="confStr"></param>
        /// <returns></returns>
        public bool SetConfig(string confStr)
        {
            string[] arr = confStr.Split('#');
            if (arr.Length != 5)
            {
                MessageBox.Show("串口配置格式不对!应该是#分隔的5位", "提示");
                return false;
            }
            cmbPortName.Text = arr[0];
            cmbBaudrate.Text = arr[1];
            cmbDataBits.Text = arr[2];
            cmbStopBits.Text = arr[3];
            cmbParity.Text = arr[4];
            return true;
        }

        /// <summary>
        /// 设置推送委托
        /// </summary>
        /// <param name="push">推送器</param>
        /// <param name="ptype">类型</param>
        /// <param name="plog">日志委托</param>
        /// <returns></returns>
        public bool SetPushDelegate(PushMessageToSwitch push, SwitchType ptype, WriteLog plog)
        {
            pushToSwitch = push;
            type = ptype;
            log = plog;
            return true;
        }

        /// <summary>
        /// 启动串口
        /// </summary>
        /// <returns></returns>
        public bool Start()
        {
            //根据当前串口对象，来判断操作
            if (comm.IsOpen)
            {
                //打开时点击，则关闭串口
                comm.Close();
            }
            //关闭时点击，则设置好端口，波特率后打开
            comm.PortName = cmbPortName.Text;
            comm.BaudRate = int.Parse(cmbBaudrate.Text);
            comm.DataBits = int.Parse(cmbDataBits.Text);
            //停止位为枚举类型非用户自定义 
            switch (cmbStopBits.Text)
            {
                default:
                    comm.StopBits = StopBits.None;
                    break;
                case "1":
                    comm.StopBits = StopBits.One;
                    break;
                case "2":
                    comm.StopBits = StopBits.Two;
                    break;
                case "1.5":
                    comm.StopBits = StopBits.OnePointFive;
                    break;
            }
            //校验位同样非用户自定义 
            switch (cmbParity.Text)
            {
                default:
                    comm.Parity = Parity.None;
                    break;
                case "Odd":
                    comm.Parity = Parity.Odd;
                    break;
                case "Even":
                    comm.Parity = Parity.Even;
                    break;
                case "Mark":
                    comm.Parity = Parity.Mark;
                    break;
                case "Space":
                    comm.Parity = Parity.Space;
                    break;
            }
            try
            {
                comm.Open();
                if (log != null)
                {
                    log("启动：启动串口成功");
                    statePortName.ForeColor = Color.Blue;
                }
            }
            catch (Exception ex)
            {
                statePortName.ForeColor = Color.Red;
                //捕获到异常信息，创建一个新的comm对象，之前的不能用了。
                comm = new SerialPort();
                //初始化SerialPort对象
                comm.NewLine = "\r\n";
                comm.RtsEnable = true;//根据实际情况吧。
                //添加事件注册
                comm.DataReceived += cmb_DataReceived;
                //现实异常信息给客户。                    
                MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK);
                return false;
            }
            return true;
        }

        /// <summary>
        /// 停止串口
        /// </summary>
        /// <returns></returns>
        public bool Stop()
        {
            if (comm.IsOpen)
            {
                comm.Close();
                statePortName.ForeColor = Color.Red;
                if (log != null)
                {
                    log("停止：串口已关闭");
                    statePortName.ForeColor = Color.Blue;
                }
            }
            return true;
        }

        /// <summary>
        /// 给串口发消息
        /// </summary>
        /// <param name="msgByteArr"></param>
        /// <returns></returns>
        public bool SendMessage(byte[] msgByteArr)
        {
            //串口打开的话就转给串口
            if (comm.IsOpen)
            {
                //转发给串口
                comm.Write(msgByteArr, 0, msgByteArr.Count());
            }
            else
            {
                if (log != null)
                {
                    log("串口未打开,无法发送");
                    statePortName.ForeColor = Color.Blue;
                }
            }
            return true;
        }

        /// <summary>
        /// 得到反射串
        /// </summary>
        /// <returns></returns>
        public string GetReflectStr()
        {
            return "MessageSwitch.UCSerialPort,MessageSwitch.dll";
        }

        /// <summary>
        /// 加载函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void UCSerialPort_Load(object sender, EventArgs e)
        {
            //初始化下拉串口名称列表框
            string[] ports = SerialPort.GetPortNames();
            //没串口提示
            if (ports == null || ports.Count() == 0)
            {
                MessageBox.Show("检测到当前运行电脑没有串口！");
            }
            Array.Sort(ports);
            cmbPortName.Items.AddRange(ports);
            //波特率
            string[] baudrates = { "1200", "2400", "4800", "9600", "19200", "38400", "57600", "115200" };
            cmbBaudrate.Items.AddRange(baudrates);
            //数据位
            string[] databits = { "8", "7", "6", "5", "4" };
            cmbDataBits.Items.AddRange(databits);
            //停止位
            string[] stopbits = { "1", "1.5", "2" };
            cmbStopBits.Items.AddRange(stopbits);
            //校验位
            string[] parity = { "None", "Odd", "Even", "Mark", "Speace" };
            cmbParity.Items.AddRange(parity);

            //默认值设置
            cmbPortName.SelectedIndex = cmbPortName.Items.Count > 0 ? 0 : -1;
            cmbBaudrate.SelectedIndex = cmbBaudrate.Items.IndexOf("9600");
            cmbDataBits.SelectedIndex = cmbDataBits.Items.IndexOf("8");
            cmbStopBits.SelectedIndex = cmbStopBits.Items.IndexOf("1");
            cmbParity.SelectedIndex = cmbParity.Items.IndexOf("None");
            //下拉框只可选择不可编辑
            cmbPortName.DropDownStyle = ComboBoxStyle.DropDownList;
            cmbBaudrate.DropDownStyle = ComboBoxStyle.DropDownList;
            cmbDataBits.DropDownStyle = ComboBoxStyle.DropDownList;
            cmbStopBits.DropDownStyle = ComboBoxStyle.DropDownList;
            cmbParity.DropDownStyle = ComboBoxStyle.DropDownList;

            //初始化SerialPort对象
            comm.NewLine = "\r\n";
            //根据实际情况吧。
            comm.RtsEnable = true;
            //添加事件注册
            comm.DataReceived += cmb_DataReceived;
        }

        /// <summary>
        /// Com口接收数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void cmb_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
            byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
            comm.Read(buf, 0, n);//读取缓冲数据
            string lineStr = System.Text.Encoding.Default.GetString(buf);
            lineStr = Util.DealNotSeeToSeeChar(lineStr);
            if (pushToSwitch != null)
            {
                pushToSwitch(buf, type);
            }


        }

        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, EventArgs e)
        {
            Start();
        }

        /// <summary>
        /// 停止
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStop_Click(object sender, EventArgs e)
        {
            Stop();
        }
    }
}

TCP服务端实现示例，实现TCP服务端接收客户端消息

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

namespace MessageSwitch
{
    ///<summary  NoteObject="Class">
    /// [功能描述:TCP服务端实现] <para/>
    /// [创建者:zlz] <para/>
    /// [创建时间:2021年11月13日] <para/>
    ///<说明>
    ///  [说明:TCP服务端实现]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public partial class UCTcpServer : UserControl, IMessageSwitch
    {
        /// <summary>
        /// 网络服务对象
        /// </summary>
        private Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        /// <summary>
        /// 是否打开
        /// </summary>
        private bool IsOpen = false;

        /// <summary>
        /// 推送器
        /// </summary>
        private PushMessageToSwitch pushToSwitch;

        /// <summary>
        /// 类型
        /// </summary>
        SwitchType type;

        /// <summary>
        /// 写日志委托
        /// </summary>
        private WriteLog log;

        /// <summary>
        /// 网络客户端
        /// </summary>
        public Socket mianClient = null;

        /// <summary>
        /// 构造函数
        /// </summary>
        public UCTcpServer()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 得到类型名字
        /// </summary>
        /// <returns></returns>
        public string GetTypeName()
        {
            return "TCP服务端";
        }

        /// <summary>
        /// 得到配置
        /// </summary>
        /// <returns></returns>
        public string GetConfig()
        {
            string confStr = txtIp.Text + "#" + txtPort.Text;
            return confStr;
        }

        /// <summary>
        /// 设置配置
        /// </summary>
        /// <param name="confStr"></param>
        /// <returns></returns>
        public bool SetConfig(string confStr)
        {
            string[] arr = confStr.Split('#');
            if (arr.Length != 2)
            {
                MessageBox.Show("TCP配置格式不对!应该是#分隔的2位", "提示");
                return false;
            }
            txtIp.Text = arr[0];
            txtPort.Text = arr[1];
            return true;
        }

        /// <summary>
        /// 设置推送委托
        /// </summary>
        /// <param name="push">推送器</param>
        /// <param name="ptype">类型</param>
        /// <param name="plog">日志委托</param>
        /// <returns></returns>
        public bool SetPushDelegate(PushMessageToSwitch push, SwitchType ptype, WriteLog plog)
        {
            pushToSwitch = push;
            type = ptype;
            log = plog;
            return true;
        }

        /// <summary>
        /// 启动
        /// </summary>
        /// <returns></returns>
        public bool Start()
        {
            if (txtPort.Text == "")
            {
                if (log != null)
                {
                    log("启动：没有设置端口号");
                }
                return false;
            }
            if (txtIp.Text == "")
            {
                if (log != null)
                {
                    log("启动：没有设置端IP");
                }
                return false;
            }
            //先释放
            if (socket != null)
            {
                socket.Close();
                socket.Dispose();
                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IsOpen = false;
            }
            //绑定IP端口
            IPAddress hostIP = IPAddress.Any;
            IPAddress.TryParse(txtIp.Text, out hostIP);
            if (Util.PortInUse(Convert.ToInt32(txtPort.Text)))
            {
                if (log != null)
                {
                    log("启动TCP服务：当前电脑端口：" + txtPort.Text + "已经被占用");
                }
                //现实异常信息给客户。                    
                MessageBox.Show("当前电脑端口：" + txtPort.Text + "已经被占用", "提示", MessageBoxButtons.OK);
                return false;
            }
            IPEndPoint ep = new IPEndPoint(hostIP, Convert.ToInt32(txtPort.Text));
            socket.Bind(ep);
            try
            {
                //开始侦听 
                socket.Listen(20);
                if (log != null)
                {
                    log("启动TCP服务：启动TCP服务成功");
                }
                stateIp.ForeColor = Color.Blue;
                Thread tcpThread = new Thread(new ThreadStart(TcpListenClientConnect));
                IsOpen = true;
                tcpThread.Start();
                return true;
            }
            catch (Exception ex)
            {
                IsOpen = false;
                //现实异常信息给客户。                    
                MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK);
                return false;
            }
        }

        /// <summary>
        /// 停止
        /// </summary>
        /// <returns></returns>
        public bool Stop()
        {
            if (socket != null)
            {
                socket.Close();
                stateIp.ForeColor = Color.Red;
                socket.Dispose();
                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IsOpen = false;
                if (log != null)
                {
                    log("停止TCP服务：TCP已释放");
                }
            }
            return true;
        }

        /// <summary>
        /// 给tcp发送消息
        /// </summary>
        /// <param name="msgByteArr"></param>
        /// <returns></returns>
        public bool SendMessage(byte[] msgByteArr)
        {
            //转发给TCP
            if (mianClient != null)
            {
                mianClient.Send(msgByteArr);
                return true;
            }
            else
            {
                if (log != null)
                {
                    log("TCP无连接客户端，无法发送，确认防火墙关闭！");
                }
                return false;
            }
        }

        /// <summary>
        /// 得到反射串
        /// </summary>
        /// <returns></returns>
        public string GetReflectStr()
        {
            return "MessageSwitch.UCTcpServer,MessageSwitch.dll";
        }

        /// <summary>
        /// 加载方法
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void UCTcpServer_Load(object sender, EventArgs e)
        {
            txtIp.Text = Util.GetIpv4Str();
        }

        /// <summary>
        /// 监听客户端连接
        /// </summary>
        private void TcpListenClientConnect()
        {
            //死循环侦听客户端连接
            while (true)
            {
                try
                {
                    if (IsOpen == false)
                    {
                        break;
                    }
                    //有客户端连接过来
                    Socket oneClient = socket.Accept();
                    string clentIP = ((IPEndPoint)oneClient.RemoteEndPoint).Address.ToString();
                    string clientPort = ((IPEndPoint)oneClient.RemoteEndPoint).Port.ToString();
                    if (log != null)
                    {
                        log("客户端:" + clentIP + ":" + clientPort + "连接了本服务");
                    }
                    //服务只接收一个客户端
                    if (mianClient == null)
                    {
                        if (log != null)
                        {
                            log("客户端:" + clentIP + ":" + clientPort + "作为主客户端");
                        }
                        mianClient = oneClient;
                        Thread newThread = new Thread(ListenClientData);
                        newThread.Start();
                    }
                    else
                    {
                        if (log != null)
                        {
                            log("已有客户端连接本服务，将断开当前客户端请求");
                        }
                        //有客户端连着就不让其他客户端连接了
                        byte[] byteArray = System.Text.Encoding.Default.GetBytes("已有连接连上该端口了!");
                        oneClient.Send(byteArray);
                        oneClient.Close();
                    }
                }
                catch (Exception ex)
                {
                    if (log != null)
                    {
                        log("服务端侦听异常：" + ex.Message);
                    }
                }
            }
        }


        /// <summary>
        /// 侦听客户端消息
        /// </summary>
        public void ListenClientData()
        {
            byte[] bytes = new byte[83886080];
            //数量
            int datai = -1;
            try
            {
                //死循环侦听客户端发来的数据
                while (true)
                {
                    if (IsOpen == false)
                    {
                        break;
                    }
                    datai = mianClient.Receive(bytes);
                    if (datai > 0)
                    {
                        if (pushToSwitch != null)
                        {
                            byte[] buf = new byte[datai];
                            Array.Copy(bytes, buf, datai);
                            pushToSwitch(buf, type);
                        }
                    }

                }
            }
            catch (System.Exception ex)
            {
                if (log != null)
                {
                    log("侦听客户端消息异常：" + ex.Message);
                }
            }
            finally
            {
                if (mianClient != null)
                {
                    mianClient.Close();
                    mianClient.Dispose();
                    mianClient = null;
                }
            }
        }

        /// <summary>
        /// 启动
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, EventArgs e)
        {
            Start();
        }

        /// <summary>
        /// 停止
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStop_Click(object sender, EventArgs e)
        {
            Stop();
        }
    }
}

工具类，共用方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml.Serialization;
using System.Net.NetworkInformation;
using System.Net;

namespace MessageSwitch
{
    ///<summary  NoteObject="Class">
    /// [功能描述:工具类] <para/>
    /// [创建者:zlz] <para/>
    /// [创建时间:2021年11月13日] <para/>
    ///<说明>
    ///  [说明:工具类]<para/>
    ///</说明>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///<修改记录>
    ///    [修改时间:本次修改时间]<para/>
    ///    [修改内容:本次修改内容]<para/>
    ///</修改记录>
    ///</summary>
    public class Util
    {
        /// <summary>
        /// 反序列化数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
        public static T ReadLocalData<T>(string path)
        {
            if (File.Exists(path))
            {
                try
                {
                    string str = ReadTxt(path);
                    byte[] arr = Convert.FromBase64String(str);
                    str = System.Text.Encoding.Default.GetString(arr);
                    return XmlDeserialize<T>(str, Encoding.UTF8);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
            else
            {
                return default(T);
            }
        }

        /// <summary>
        /// 序列化数据
        /// </summary>
        /// <param name="data"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        public static bool WriteLocalData(object data, string path)
        {
            if (File.Exists(path))
            {
                File.Delete(path);
                try
                {
                    string str = Serializer(data.GetType(), data);
                    byte[] arr = System.Text.Encoding.Default.GetBytes(str);
                    str = Convert.ToBase64String(arr);
                    WriteTxt(path, str);
                    return true;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
            else
            {
                try
                {
                    string str = Serializer(data.GetType(), data);
                    byte[] arr = System.Text.Encoding.Default.GetBytes(str);
                    str = Convert.ToBase64String(arr);
                    WriteTxt(path, str);
                    return true;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        /// <summary>
        /// 删除本地数据
        /// </summary>
        /// <param name="id">Id</param>
        /// <param name="pat">路径，不给的话有方法默认决定</param>
        /// <returns>结果</returns>
        public static bool DeleteLocalData(string id, string pat)
        {
            string path = Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), id + ".aup");
            if (pat != null && pat != string.Empty)
            {
                path = Path.Combine(pat, id + ".aup");
            }
            if (File.Exists(path))
            {
                File.Delete(path);
            }
            return true;
        }

        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="type">类型</param>
        /// <param name="obj">对象</param>
        /// <returns></returns>
        public static string Serializer(Type type, object obj)
        {
            MemoryStream Stream = new MemoryStream();
            XmlSerializer xml = new XmlSerializer(type);
            try
            {
                //序列化对象
                xml.Serialize(Stream, obj);
            }
            catch (InvalidOperationException)
            {
                throw;
            }
            Stream.Position = 0;
            StreamReader sr = new StreamReader(Stream);
            string str = sr.ReadToEnd();

            sr.Dispose();
            Stream.Dispose();

            return str;
        }

        /// <summary>
        /// 从XML字符串中反序列化对象
        /// </summary>
        /// <typeparam name="T">结果对象类型</typeparam>
        /// <param name="s">包含对象的XML字符串</param>
        /// <param name="encoding">编码方式</param>
        /// <returns>反序列化得到的对象</returns>
        public static T XmlDeserialize<T>(string s, Encoding encoding)
        {
            try
            {
                if (string.IsNullOrEmpty(s))
                {
                    throw new ArgumentNullException("s");
                }
                if (encoding == null)
                {
                    throw new ArgumentNullException("encoding");
                }

                XmlSerializer mySerializer = new XmlSerializer(typeof(T));
                using (MemoryStream ms = new MemoryStream(encoding.GetBytes(s)))
                {
                    using (StreamReader sr = new StreamReader(ms, encoding))
                    {
                        return (T)mySerializer.Deserialize(sr);
                    }
                }
            }
            catch (Exception ex)
            {
                return default(T);
            }
        }

        /// <summary>
        /// 读取文件数据
        /// </summary>
        /// <param name="path">文件全路径</param>
        /// <returns></returns>
        public static string ReadTxt(string path)
        {
            //文件流
            FileStream fs = null;
            try
            {
                //创建文件流
                fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                //创建字符串读取器
                StreamReader sr = new StreamReader(fs);
                //读到尾
                string str = sr.ReadToEnd();
                return str;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                }
            }
        }

        /// <summary>
        /// 写入数据到指定文件
        /// </summary>
        /// <param name="path">文件全路径</param>
        /// <param name="str">数据</param>
        /// <param name="isReplace">是否提换，默认为替换，否则为添加</param>
        /// <returns></returns>
        public  static bool WriteTxt(string path, string str)
        {
            FileStream fs = null;
            StreamWriter sw1 = null;
            try
            {
                if (File.Exists(path))
                {
                    File.Delete(path);
                }
                //创建文件流
                fs = new FileStream(path, FileMode.CreateNew);
                //创建字符串写入器
                sw1 = new StreamWriter(fs);
                //写入字符串
                sw1.Write(str);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (sw1 != null)
                {
                    sw1.Close();
                }
                if (fs != null)
                {
                    fs.Close();
                }
            }
        }

        /// <summary>
        /// 处理不可见字符
        /// </summary>
        /// <param name="data">数据</param>
        /// <returns>返回</returns>
        public static string DealNotSeeToSeeChar(string data)
        {
            for (int i = 0; i <= 31; i++)
            {
                if (i == 6)
                {
                    data = data.Replace((char)i + "", "[ACK]");
                }
                else if (i == 5)
                {
                    data = data.Replace((char)i + "", "[ENQ]");
                }
                else if (i == 4)
                {
                    data = data.Replace((char)i + "", "[EOT]");
                }
                else if (i == 3)
                {
                    data = data.Replace((char)i + "", "[ETX]");
                }
                else if (i == 2)
                {
                    data = data.Replace((char)i + "", "[STX]");
                }
                else
                {
                    data = data.Replace((char)i + "", "[" + i + "]");
                }
            }
            data.Replace((char)127 + "", "[127]");
            return data;
        }

        /// <summary>
        /// 判断端口是否被占用
        /// </summary>
        /// <param name="port">端口</param>
        /// <returns></returns>
        public static bool PortInUse(int port)
        {
            bool inUse = false;

            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
            IPEndPoint[] ipEndPoints = ipProperties.GetActiveTcpListeners();

            foreach (IPEndPoint endPoint in ipEndPoints)
            {
                if (endPoint.Port == port)
                {
                    inUse = true;
                    break;
                }
            }
            return inUse;
        }

        /// <summary>
        /// 获得当前机器的ip4串
        /// </summary>
        /// <returns></returns>
        public static string GetIpv4Str()
        {
            System.Net.IPAddress[] arrIPAddresses = System.Net.Dns.GetHostAddresses(System.Net.Dns.GetHostName());
            foreach (System.Net.IPAddress ip in arrIPAddresses)
            {
                if (ip.AddressFamily.Equals(System.Net.Sockets.AddressFamily.InterNetwork))
                {
                    return ip.ToString();
                }
            }
            return string.Empty;
        }
    }
}

运行效果-串口转串口和TCP服务

这样就可以任意组合转换器两端的协议了。可以串口转串口，串口转tcp，tcp转tcp，tcp转tdp，串口转udp====。而且每端可以配置多种协议。所以把这个称为超级转换器。分为转换中心和转换实现。

善于抽取共性，就能大大降低复杂度，实现灵活又强大的功能，面向接口编程的好处。