C# 读写XML文档 通讯 算法 自定义协议

/*
 * API说明文档
 * 本文档共包含五个类：
 *                     XML文件操作类->XMLConcrol
 *                     串口通讯类   ->ComTransmit
 *                     网络通讯类   ->NetTransmit
 *                     算法类       ->Algorithm
 *                     通讯协议类   ->Protocol
 *********************************************************                     
 * XML文件操作类->XMLConcrol说明:
 * 
 * 原型:public void LoadFile()
 * 功能：加载配置文件。如默认配置文件不存在，则新建一个
 * 输入参数：无
 * 输出参数：无
 * 返回值：无
 * 
 * 原型:public void readNode(string nodeName,ref float k,ref float b)
 * 功能：读取指定节点值        标定模板一阶线性：y=kx+b
 * 输入参数: 节点名称 nodeName 类型 string
 * 输出参数: 标校系数 k        类型 ref float
 *           标校常数 b        类型 ref float
 * 返回值：无
 * 
 * 原型:public void addNode(string nodeName, float k, float b)
 * 功能：增加指定名称的节点    标定模板一阶线性：y=kx+b
 * 输入参数: 节点名称 nodeName 类型 string
 *           标校系数 k        类型 float
 *           标校常数 b        类型 float
 * 输出参数：无
 * 返回值：无
 * 
 * 原型:public void replaceNode(string nodeName, float k, float b)
 * 功能：替换指定名称的节点    标定模板一阶线性：y=kx+b
 * 输入参数: 节点名称 nodeName 类型 string
 *           标校系数 k        类型 float
 *           标校常数 b        类型 float
 * 输出参数：无
 * 返回值：无
 * 
 * 原型:public void nodeList(ref ArrayList nodeList, ref int nodeNum)
 * 功能：获取所有节点的名称列表
 * 输入参数：无
 * 输出参数：节点名称列表 nodeList 类型 ref ArrayList
 *           节点列表长度 nodeNum  类型 ref int
 * 返回值：无
 * 
 * 原型:public int removeNode(string nodeName)
 * 功能：删除指定名称的节点
 * 输入参数: 节点名称 nodeName 类型 string
 * 输出参数：无
 * 返回值：删除节点个数       
 *********************************************************
 * 串口通讯类->ComTransmit说明:
 * 
 * 原型:public void InitCom(string comPort,int rate)
 * 功能：初始化串口
 * 输入参数：串口名 comPort 类型 string
 *           波特率 rate    类型 int
 *
 * 原型:public void comWrite(string text)
 * 功能：串口发送
 * 输入参数：名称 text 类型 string
 *
 * 原型:public void comWrite(byte[] text)
 * 功能：串口发送
 * 输入参数：名称 text 类型 byte[]
 * 
 * 原型:public void comRead(ref byte[] text)
 * 功能：串口接收
 * 输出参数：名称 text 类型 ref byte[]
 * 
 * 原型:public void comRead(ref string text)
 * 功能：串口接收
 * 输出参数：名称 text 类型 ref string
 *********************************************************
 * 网络通讯类->NetTransmit说明:
 * 
 * 原型:public void startServer(byte[] ServerAddress)
 * 功能：创建一个服务器
 * 输入参数:服务器IP地址 ServerAddress 类型 byte[]
 *          例：byte[] ServerAddress=new byte[]{192,168,0,1}
 * 
 * 原型:public void startServer(string ServerAddress)
 * 功能：创建一个服务器
 * 输入参数:服务器IP地址 ServerAddress 类型 string
 *          例：string ServerAddress="192.168.0.1";
 *          
 * 原型:public bool serverReciveData(ref string msg)
 * 功能：服务器接受来自客户端的数据
 * 输出参数：名称 msg 类型 ref string
 * 返回值：是否读取成功 成功 true 失败 false
 * 
 * 原型:public bool serverReciveData(ref byte[] msg)
 * 功能：服务器接受来自客户端的数据
 * 输出参数：名称 msg 类型 ref byte[]
 * 返回值：是否读取成功 成功 true 失败 false
 * 
 * 原型:public void serverSendData(byte[] msg)
 * 功能：服务器发送数据到客户端
 * 输入参数：名称 msg 类型 byte[]
 * 返回值：无
 * 
 * 原型:public void serverSendData(string msg)
 * 功能：服务器发送数据到客户端
 * 输入参数：名称 msg 类型 string
 * 返回值：无
 * 
 * 原型:public void startClient(byte[] ServerAddress)
 * 功能：建立一个客户端
 * 输入参数:服务器IP地址 ServerAddress 类型 byte[]
 *          例：byte[] ServerAddress=new byte[]{192,168,0,1}
 *          
 * 原型:public void startClient(string ServerAddress)
 * 功能：建立一个客户端
 * 输入参数:服务器IP地址 ServerAddress 类型 string
 *          例：string ServerAddress="192.168.0.1"
 *          
 * 原型:public bool clientReciveData(ref string msg)
 * 功能：客户端接受来自服务器的数据
 * 输出参数：名称 msg 类型 ref string
 * 返回值：是否读取成功 成功 true 失败 false
 * 
 * 原型:public bool clientReciveData(ref byte[] msg)
 * 功能：客户端接受来自服务器的数据
 * 输出参数：名称 msg 类型 ref byte[]
 * 返回值：是否读取成功 成功 true 失败 false
 * 
 * 原型:public void clientSendData(byte[] msg)
 * 功能：客户端发送数据到服务器
 * 输入参数：名称 msg 类型 byte[]
 * 返回值：无
 * 
 * 原型:public void clientSendData(string msg)
 * 功能：客户端发送数据到服务器
 * 输入参数：名称 msg 类型 string
 * 返回值：无
 *********************************************************
 * 算法类->Algorithm说明：
 * 
 * 原型:public uint flaotToHex(float f)
 * 功能：浮点数转换为IEEE754格式整数
 * 输入参数：名称 f 类型 float
 * 返回值：符合IEEE754的无符号整形
 * 
 * 原型:public string flaotToHexString(float f)
 * 功能：浮点数转换为IEEE754格式十六进制字符串
 * 输入参数：名称 f 类型 float
 * 返回值：符合IEEE754的十六进制字符串
 * 
 * 原型:public float hexTofloat(uint hex)
 * 功能：符合IEEE754的无符号整形转换为浮点数
 * 输入参数：名称 hex 类型 uint
 * 返回值：浮点数
 * 
 * 原型:public float hexStringTofloat(string hex)
 * 功能：符合IEEE754的十六进制字符串转换为浮点数
 * 输入参数：名称 hex 类型 string
 * 返回值：浮点数
 * 
 * 原型:public void curveFitting(double[] x, double[] y, int n, ref double[] a, int m)
 * 功能：切比雪夫曲线拟合
 * 输入参数：X轴坐标数组  x 类型 double[]
 *           Y轴坐标数组  y 类型 double[]
 *           数组取样点数 n 类型 int
 *           拟合阶数     m 类型 int                m=拟合阶数+1 如：一阶拟合 m=2 则：y=a0+a1*x
 * 输出参数：拟合系数     a 类型 ref double[]       数组长度=m+1 如：一阶拟合 double[] a=new double[3] 还原后为y=a[0]+a[1]*x 最大均方差存在a[2]里 
 *                                                  y=a[0]+a[1]*x+a[2]*x^2+a[3]*x^3 ……………………
 *                                                  
 *********************************************************
 * 通讯协议类->Protocol说明：
 *
 * 原型:public string analysis(string order)
 * 功能：解析指令
 * 输入参数：用户指令 order 类型 string
 *           查询指令：
 *                    返回所有节点名称     “node list ？”
 *                    读取指定节点的值     “read node ? nodeName”
 *           设置指令：
 *                    增加节点             “add node #nodeName #k #b”
 *                    更新指定名称的节点   “replace node #nodeName #k #b”
 *                    删除指定名称的节点   “remove node #nodeName”
 * 返回值：返回查询指令的结果字符串
*/


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.IO.Ports;
using System.Xml;
using System.Collections;
using System.Net;
using System.Net.Sockets;


namespace ConfigFileReadWrite
{
    //XML文件操作类
    public class XMLConcrol 
    {
        //文件名，默认为当前可执行文件目录下config.xml
        String fileName = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase+"config.xml";
        XmlDocument xml = new XmlDocument();


        /*
         * 功能：加载配置文件。如默认配置文件不存在，则新建一个
         * 输入参数：无
         * 输出参数：无
         * 返回值：无
        */
        public void LoadFile()
        {
            FileInfo fileInfo = new FileInfo(fileName);
            if (!fileInfo.Exists)
            {
                XmlNode node = xml.CreateXmlDeclaration("1.0", "gb2312", "");
                xml.AppendChild(node);
                XmlNode root = xml.CreateElement("root");
                xml.AppendChild(root);                
                xml.Save(fileName);                
            }
            xml.Load(fileName);
        }


        /*
         * 功能：读取指定节点值        标定模板一阶线性：y=kx+b
         * 输入参数: 节点名称 nodeName 类型 string
         * 输出参数: 标校系数 k        类型 ref float
         *           标校常数 b        类型 ref float
         * 返回值：无
        */
        public void readNode(string nodeName,ref float k,ref float b)
        {
            XmlNode root = xml.SelectSingleNode("root");
            if (xml.SelectSingleNode("root").ChildNodes.Count > 0)
            {
                XmlNode nodeOne = root.SelectSingleNode(nodeName);
                k = (float)Convert.ToDouble((nodeOne.SelectSingleNode("k")).InnerText);
                b = (float)Convert.ToDouble((nodeOne.SelectSingleNode("b")).InnerText);
            }
        }


        /*
         * 功能：增加指定名称的节点    标定模板一阶线性：y=kx+b
         * 输入参数: 节点名称 nodeName 类型 string
         *           标校系数 k        类型 float
         *           标校常数 b        类型 float
         * 输出参数：无
         * 返回值：无
        */
        public void addNode(string nodeName, float k, float b)
        {
            XmlNode root = xml.SelectSingleNode("root");
            XmlElement newNode = xml.CreateElement(nodeName); 
            XmlElement inNewNode1 = xml.CreateElement("k");
            XmlElement inNewNode2 = xml.CreateElement("b");


            inNewNode1.InnerText = Convert.ToString(k);
            inNewNode2.InnerText = Convert.ToString(b);


            root.AppendChild(newNode);
            newNode.AppendChild(inNewNode1);
            newNode.AppendChild(inNewNode2);


            xml.Save(fileName);
        }


        /*
         * 功能：替换指定名称的节点    标定模板一阶线性：y=kx+b
         * 输入参数: 节点名称 nodeName 类型 string
         *           标校系数 k        类型 float
         *           标校常数 b        类型 float
         * 输出参数：无
         * 返回值：无
        */
        public void replaceNode(string nodeName, float k, float b)
        {
            XmlNode root = xml.SelectSingleNode("root");
            if (xml.SelectSingleNode("root").ChildNodes.Count > 0)
            {
                XmlNode nodeOne = root.SelectSingleNode(nodeName);
                (nodeOne.SelectSingleNode("k")).InnerText = Convert.ToString(k);
                (nodeOne.SelectSingleNode("b")).InnerText = Convert.ToString(b);
                xml.Save(fileName);
            }
        }


        /*
         * 功能：获取所有节点的名称列表
         * 输入参数：无
         * 输出参数：节点名称列表 nodeList 类型 ref ArrayList
         *           节点列表长度 nodeNum  类型 ref int
         * 返回值：无
        */
        public void nodeList(ref ArrayList nodeList, ref int nodeNum)
        {        
            XmlNodeList topM = xml.SelectSingleNode("root").ChildNodes;
            nodeNum = xml.SelectSingleNode("root").ChildNodes.Count;
            foreach(XmlElement element in topM)  
            {
                nodeList.Add(element.Name);
            }            
        }


        /*
         * 功能：删除指定名称的节点
         * 输入参数: 节点名称 nodeName 类型 string
         * 输出参数：无
         * 返回值：删除节点个数
        */
        public int removeNode(string nodeName)
        {
            int removeNum = 0;
            XmlNodeList topM = xml.SelectSingleNode("root").ChildNodes;
            foreach (XmlElement element in topM)
            {
                if (element.Name == nodeName)
                {
                    element.ParentNode.RemoveChild(element);
                    removeNum++;
                }
            }
            xml.Save(fileName);
            return removeNum;
        }
    }


    //串口通讯类
    public class ComTransmit
    {
        SerialPort serialPort;


        /*
         * 功能：初始化串口
         * 输入参数：串口名 comPort 类型 string
         *           波特率 rate    类型 int
        */
        public void InitCom(string comPort,int rate)
        {
            serialPort = new SerialPort();
            serialPort.PortName = comPort;                //串口COM3
            serialPort.BaudRate = rate;                   //波特率38400
            serialPort.Parity = Parity.None;              //无校验位
            serialPort.StopBits = StopBits.One;           //停止位1
            serialPort.DataBits = 8;                      //数据位8
            serialPort.Open();
        }


        /*
         * 功能：串口发送
         * 输入参数：名称 text 类型 string
        */
        public void comWrite(string text)
        {
            serialPort.WriteLine(text);
        }


        /*
         * 功能：串口发送
         * 输入参数：名称 text 类型 byte[]
        */
        public void comWrite(byte[] text)
        {
            serialPort.Write(text,0,text.GetLength(0));
        }


        /*
         * 功能：串口接收
         * 输出参数：名称 text 类型 ref byte[]
        */
        public void comRead(ref byte[] text)
        {
            int num = serialPort.BytesToRead;
            int max = (text.GetLength(0) > num) ? text.GetLength(0) : num;
            for (int loop = 0; loop < max; loop++)
            {
                text[loop]=(byte)serialPort.ReadByte();
            }
        }


        /*
         * 功能：串口接收
         * 输出参数：名称 text 类型 ref string
        */
        public void comRead(ref string text)
        {
            text = serialPort.ReadLine();
        }
    }


    //网络通讯类
    public class NetTransmit
    {
        int BufferSize = 8192;
        IPAddress ip;
        TcpListener listener;
        NetworkStream streamToClient, streamToServer;
        TcpClient client, remoteClient;


        /*
         * 功能：创建一个服务器
         * 输入参数:服务器IP地址 ServerAddress 类型 byte[]
         *          例：byte[] ServerAddress=new byte[]{192,168,0,1}
        */
        public void startServer(byte[] ServerAddress)
        {
            ip = new IPAddress(ServerAddress);
            listener = new TcpListener(ip, 8500);
            listener.Start();
            remoteClient = listener.AcceptTcpClient();
            streamToClient = remoteClient.GetStream();
        }


        /*
         * 功能：创建一个服务器
         * 输入参数:服务器IP地址 ServerAddress 类型 string
         *          例：string ServerAddress="192.168.0.1";
        */
        public void startServer(string ServerAddress)
        {
            ip = IPAddress.Parse(ServerAddress);
            listener = new TcpListener(ip, 8500);
            listener.Start();
            remoteClient = listener.AcceptTcpClient();
            streamToClient = remoteClient.GetStream();
        }


        /*
         * 功能：服务器接受来自客户端的数据
         * 输出参数：名称 msg 类型 ref string
         * 返回值：是否读取成功 成功 true 失败 false
        */
        public bool serverReciveData(ref string msg)
        {
            byte[] buffer = new byte[BufferSize];
            int bytesRead=0;
            MemoryStream msStream = new MemoryStream();
            streamToClient = remoteClient.GetStream();
            for (int loop = 0; loop < 50; loop++)
            {
                bytesRead = streamToClient.Read(buffer, 0, BufferSize);
            }
            msStream.Write(buffer, 0, bytesRead);
            buffer = msStream.GetBuffer();
            msg = System.Text.Encoding.ASCII.GetString(buffer);


            return bytesRead>0;
        }


        /*
         * 功能：服务器接受来自客户端的数据
         * 输出参数：名称 msg 类型 ref byte[]
         * 返回值：是否读取成功 成功 true 失败 false
        */
        public bool serverReciveData(ref byte[] msg)
        {
            byte[] buffer = new byte[BufferSize];
            int bytesRead = 0;
            MemoryStream msStream = new MemoryStream();
            streamToClient = remoteClient.GetStream();
            for (int loop = 0; loop < 50; loop++)
            {
                bytesRead = streamToClient.Read(buffer, 0, BufferSize);
            }            


            return bytesRead > 0;
        }


        /*
         * 功能：服务器发送数据到客户端
         * 输入参数：名称 msg 类型 byte[]
         * 返回值：无
        */
        public void serverSendData(byte[] msg)
        {
            streamToClient = remoteClient.GetStream();
            streamToClient.Write(msg, 0, msg.GetLength(0));            
        }


        /*
         * 功能：服务器发送数据到客户端
         * 输入参数：名称 msg 类型 string
         * 返回值：无
        */
        public void serverSendData(string msg)
        {
            streamToClient = remoteClient.GetStream();
            byte[] buffer = System.Text.Encoding.Default.GetBytes(msg);            
            streamToClient.Write(buffer, 0, buffer.GetLength(0));
        }


        /*
         * 功能：建立一个客户端
         * 输入参数:服务器IP地址 ServerAddress 类型 byte[]
         *          例：byte[] ServerAddress=new byte[]{192,168,0,1}
        */
        public void startClient(byte[] ServerAddress)
        {
            string sa = System.Text.Encoding.Default.GetString(ServerAddress);
            client = new TcpClient();
            client.Connect(sa, 8500);
            streamToServer = client.GetStream();
        }


        /*
         * 功能：建立一个客户端
         * 输入参数:服务器IP地址 ServerAddress 类型 string
         *          例：string ServerAddress="192.168.0.1"
        */
        public void startClient(string ServerAddress)
        {
            client = new TcpClient();
            client.Connect(ServerAddress, 8500);
            streamToServer = client.GetStream();
        }


        /*
         * 功能：客户端接受来自服务器的数据
         * 输出参数：名称 msg 类型 ref string
         * 返回值：是否读取成功 成功 true 失败 false
        */
        public bool clientReciveData(ref string msg)
        {
            byte[] buffer = new byte[BufferSize];
            int bytesRead = 0;
            MemoryStream msStream = new MemoryStream();
            streamToServer = client.GetStream();
            for (int loop = 0; loop < 50; loop++)
            {
                bytesRead = streamToServer.Read(buffer, 0, BufferSize);
            }
            msStream.Write(buffer, 0, bytesRead);
            buffer = msStream.GetBuffer();
            msg = System.Text.Encoding.ASCII.GetString(buffer);


            return bytesRead > 0;
        }


        /*
         * 功能：客户端接受来自服务器的数据
         * 输出参数：名称 msg 类型 ref byte[]
         * 返回值：是否读取成功 成功 true 失败 false
        */
        public bool clientReciveData(ref byte[] msg)
        {
            byte[] buffer = new byte[BufferSize];
            int bytesRead = 0;
            MemoryStream msStream = new MemoryStream();
            streamToServer = client.GetStream();
            for (int loop = 0; loop < 50; loop++)
            {
                bytesRead = streamToServer.Read(buffer, 0, BufferSize);
            }


            return bytesRead > 0;
        }


        /*
         * 功能：客户端发送数据到服务器
         * 输入参数：名称 msg 类型 byte[]
         * 返回值：无
        */
        public void clientSendData(byte[] msg)
        {
            streamToServer = client.GetStream();
            streamToServer.Write(msg, 0, msg.GetLength(0));
        }


        /*
         * 功能：客户端发送数据到服务器
         * 输入参数：名称 msg 类型 string
         * 返回值：无
        */
        public void clientSendData(string msg)
        {
            streamToServer = client.GetStream();
            byte[] buffer = System.Text.Encoding.Default.GetBytes(msg);
            streamToServer.Write(buffer, 0, buffer.GetLength(0));
        }
    }


    //算法类
    public class Algorithm
    {
        /*
         * 功能：浮点数转换为IEEE754格式整数
         * 输入参数：名称 f 类型 float
         * 返回值：符合IEEE754的无符号整形
        */
        public uint flaotToHex(float f)
        {
            return BitConverter.ToUInt32(BitConverter.GetBytes(f), 0);
        }


        /*
         * 功能：浮点数转换为IEEE754格式十六进制字符串
         * 输入参数：名称 f 类型 float
         * 返回值：符合IEEE754的十六进制字符串
        */
        public string flaotToHexString(float f)
        {
            return Convert.ToString(BitConverter.ToUInt32(BitConverter.GetBytes(f), 0), 16);
        }


        /*
         * 功能：符合IEEE754的无符号整形转换为浮点数
         * 输入参数：名称 hex 类型 uint
         * 返回值：浮点数
        */
        public float hexTofloat(uint hex)
        {
            return BitConverter.ToSingle(BitConverter.GetBytes(hex), 0);
        }


        /*
         * 功能：符合IEEE754的十六进制字符串转换为浮点数
         * 输入参数：名称 hex 类型 string
         * 返回值：浮点数
        */
        public float hexStringTofloat(string hex)
        {
            return BitConverter.ToSingle(BitConverter.GetBytes(Convert.ToUInt32(hex)), 0);
        }


        /*
         * 功能：切比雪夫曲线拟合
         * 输入参数：X轴坐标数组  x 类型 double[]
         *           Y轴坐标数组  y 类型 double[]
         *           数组取样点数 n 类型 int
         *           拟合阶数     m 类型 int                m=拟合阶数+1 如：一阶拟合 m=2 则：y=a0+a1*x
         * 输出参数：拟合系数     a 类型 ref double[]       数组长度=m+1 如：一阶拟合 double[] a=new double[3] 还原后为y=a[0]+a[1]*x 最大均方差存在a[2]里 
         *                                                  y=a[0]+a[1]*x+a[2]*x^2+a[3]*x^3 ……………………
        */
        public void curveFitting(double[] x, double[] y, int n, ref double[] a, int m)
        {
            int m1, i, j, l, ii, k, im;
            int[] ix = new int[21];
            double ha, hh, y1, y2, h1, h2, d, hm;
            double[] h = new double[21];
            for (i = 0; i <= m; i++)
            {
                a[i] = 0.0;
            }
            if (m >= n) m = n - 1;
            if (m >= 20) m = 19;
            m1 = m + 1;
            ha = 0.0;
            ix[0] = 0; ix[m] = n - 1;
            l = (n - 1) / m; j = l;
            for (i = 1; i <= m - 1; i++)
            { ix[i] = j; j = j + l; }
            while (1 == 1)
            {
                hh = 1.0;
                for (i = 0; i <= m; i++)
                { a[i] = y[ix[i]]; h[i] = -hh; hh = -hh; }
                for (j = 1; j <= m; j++)
                {
                    ii = m1; y2 = a[ii - 1]; h2 = h[ii - 1];
                    for (i = j; i <= m; i++)
                    {
                        d = x[ix[ii - 1]] - x[ix[m1 - i - 1]];
                        y1 = a[m - i + j - 1];
                        h1 = h[m - i + j - 1];
                        a[ii - 1] = (y2 - y1) / d;
                        h[ii - 1] = (h2 - h1) / d;
                        ii = m - i + j; y2 = y1; h2 = h1;
                    }
                }
                hh = -a[m] / h[m];
                for (i = 0; i <= m; i++)
                    a[i] = a[i] + h[i] * hh;
                for (j = 1; j <= m - 1; j++)
                {
                    ii = m - j; d = x[ix[ii - 1]];
                    y2 = a[ii - 1];
                    for (k = m1 - j; k <= m; k++)
                    {
                        y1 = a[k - 1]; a[ii - 1] = y2 - d * y1;
                        y2 = y1; ii = k;
                    }
                }
                hm = Math.Abs(hh);
                if (hm <= ha) { a[m] = -hm; return; }
                a[m] = hm; ha = hm; im = ix[0]; h1 = hh;
                j = 0;
                for (i = 0; i <= n - 1; i++)
                {
                    if (i == ix[j])
                    { if (j < m) j = j + 1; }
                    else
                    {
                        h2 = a[m - 1];
                        for (k = m - 2; k >= 0; k--)
                            h2 = h2 * x[i] + a[k];
                        h2 = h2 - y[i];
                        if (Math.Abs(h2) > hm)
                        { hm = Math.Abs(h2); h1 = h2; im = i; }
                    }
                }
                if (im == ix[0]) return;
                i = 0; l = 1;
                while (l == 1)
                {
                    l = 0;
                    if (im >= ix[i])
                    {
                        i = i + 1;
                        if (i <= m) l = 1;
                    }
                }
                if (i > m) i = m;
                if (i == (i / 2) * 2) h2 = -hh;
                else h2 = hh;
                if (h1 * h2 >= 0.0) ix[i] = im;
                else
                {
                    if (im < ix[0])
                    {
                        for (j = m - 1; j >= 0; j--)
                            ix[j + 1] = ix[j];
                        ix[0] = im;
                    }
                    else
                    {
                        if (im > ix[m])
                        {
                            for (j = 1; j <= m; j++)
                                ix[j - 1] = ix[j];
                            ix[m] = im;
                        }
                        else ix[i - 1] = im;
                    }
                }
            }
        }
    }


    //通讯协议类
    public class Protocol
    {
        private string readNodeList()
        {
            ArrayList nodeList=new ArrayList();
            int nodeNum=0;
            XMLConcrol xml=new XMLConcrol();
            string bckVal="";


            xml.LoadFile();
            xml.nodeList(ref nodeList, ref nodeNum);


            for (int loop = 0; loop < nodeNum-1; loop++)
            {
                bckVal = bckVal + nodeList[loop] + ",";
            }
            bckVal += nodeList[nodeNum - 1];
            return bckVal;
        }
        
        private string readNode(string nodeName)
        {
            XMLConcrol xml = new XMLConcrol();
            string bckVal = "";
            float k=0,b=0;


            xml.LoadFile();
            xml.readNode(nodeName, ref k, ref b);
            bckVal = "k," + k + ",b," + b;
            return bckVal;
        }


        private void addNode(string nodeName, float k, float b)
        {
            XMLConcrol xml = new XMLConcrol();
            
            xml.addNode(nodeName, k, b);
        }


        private void replaceNode(string nodeName, float k, float b)
        {
            XMLConcrol xml = new XMLConcrol();


            xml.replaceNode(nodeName, k, b);
        }


        private void removeNode(string nodeName)
        {
            XMLConcrol xml = new XMLConcrol();


            xml.removeNode(nodeName);
        }


        /*
         * 功能：解析指令
         * 输入参数：用户指令 order 类型 string
         *           查询指令：
         *                    返回所有节点名称     “node list ？”
         *                    读取指定节点的值     “read node ? nodeName”
         *           设置指令：
         *                    增加节点             “add node #nodeName #k #b”
         *                    更新指定名称的节点   “replace node #nodeName #k #b”
         *                    删除指定名称的节点   “remove node #nodeName”
         * 返回值：返回查询指令的结果字符串
        */
        public string analysis(string order)
        {
            string bckVal = "";
            string[] command = order.Split(',');
            foreach (string subCommand in command)
            {
                if (subCommand.IndexOf('#') > 0)
                {
                    string[] str = subCommand.Split('#');
                    str[0] = str[0].Trim();
                    switch (str[0])
                    {
                        case "add node":
                            str[1] = str[1].Trim();
                            str[2] = str[2].Trim();
                            str[3] = str[3].Trim();
                            addNode(str[1], (float)Convert.ToDouble(str[2]), (float)Convert.ToDouble(str[3]));
                            break;
                        case "replace node":
                            str[1] = str[1].Trim();
                            str[2] = str[2].Trim();
                            str[3] = str[3].Trim();
                            replaceNode(str[1], (float)Convert.ToDouble(str[2]), (float)Convert.ToDouble(str[3]));
                            break;
                        case "remove node":
                            str[1] = str[1].Trim();
                            removeNode(str[1]);
                            break;
                    }
                }


                if (subCommand.IndexOf('?') > 0)
                {
                    string[] str = subCommand.Split('?');
                    str[0] = str[0].Trim();
                    switch (str[0])
                    {
                        case "node list":
                            bckVal=readNodeList();
                            break;
                        case "read node":
                            str[1] = str[1].Trim();
                            bckVal = readNode(str[1]);
                            break;
                    }
                }
            }
            return bckVal;
        }
    }
}