基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：813200300

本次赞助数额为： 10 元　

支付宝支付

微信支付

   源码介绍

---

1.最多可同时ping不少于20个ip，ip附有描述信息，描述设备名称
2.ip可以增删改
3.ip可设置使能与不使能
4.可设置ping的间隔时间，一个参数，统一设置
5.有ping不通的，消息栏显示红字，并打到日志文件
6.各Ip有实时状态，有设备描述，ping得通实时状态显示绿色，ping不通时状态改为红色，恢复ping得通时状态显示绿色，使用tree控件
7.开机自启动
8.按退出按钮时不退出只是界面最小化到任务栏图标，单击图标又显示界面，右键单击图标弹出菜单，可以真正退出

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

namespace PingTestTool
{
    public partial class Form1 : Form
    {
        public static Form1 form1;//定义静态对象，用于form1上的richTextBox1的消息显示
        public Config config;



        public Form1()
        {
            DateTime beforDT = System.DateTime.Now;
            InitializeComponent();
            form1 = this;//对静态对象赋值，静态对象form1引用本Form1窗体,，用于其他类中调用form1上的richTextBox1进行消息显示
            config = new Config();


            #region  //状态栏显示相关代码
            toolStripStatusLabel2.Text= config.ReadConfigFile("equipmentName");
            toolStripStatusLabel3.Text= "运行中";
            toolStripStatusLabel4.Text = "软件启动时间：" DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");//状态栏显示软件启动时间

            string name = Dns.GetHostName();//状态栏显示本机的计算机名称
            toolStripStatusLabel5.Text = "本机计算机名称：" name;//状态栏显示本机的计算机名称

            string ip = string.Empty;
            IPAddress[] ipadrlist = Dns.GetHostAddresses(name);
            foreach (IPAddress ipa in ipadrlist)
            {
                if (ipa.AddressFamily == AddressFamily.InterNetwork)
                {
                    ip = ipa.ToString();
                }

            }
            toolStripStatusLabel6.Text = "本机IP：" ip;
            #endregion


            #region  //读取配置文件信息显示到配置栏

            textBox1.Text = config.ReadConfigFile("ip1Address");
            textBox101.Text = config.ReadConfigFile("ip1Describe");
            checkBox1.Checked = bool.Parse(config.ReadConfigFile("ip1IsEnable"));
            textBox2.Text = config.ReadConfigFile("ip2Address");
            textBox102.Text = config.ReadConfigFile("ip2Describe");
            checkBox2.Checked = bool.Parse(config.ReadConfigFile("ip2IsEnable"));
            textBox3.Text = config.ReadConfigFile("ip3Address");
            textBox103.Text = config.ReadConfigFile("ip3Describe");
            checkBox3.Checked = bool.Parse(config.ReadConfigFile("ip3IsEnable"));
            textBox4.Text = config.ReadConfigFile("ip4Address");
            textBox104.Text = config.ReadConfigFile("ip4Describe");
            checkBox4.Checked = bool.Parse(config.ReadConfigFile("ip4IsEnable"));
            textBox5.Text = config.ReadConfigFile("ip5Address");
            textBox105.Text = config.ReadConfigFile("ip5Describe");
            checkBox5.Checked = bool.Parse(config.ReadConfigFile("ip5IsEnable"));
            textBox6.Text = config.ReadConfigFile("ip6Address");
            textBox106.Text = config.ReadConfigFile("ip6Describe");
            checkBox6.Checked = bool.Parse(config.ReadConfigFile("ip6IsEnable"));
            textBox7.Text = config.ReadConfigFile("ip7Address");
            textBox107.Text = config.ReadConfigFile("ip7Describe");
            checkBox7.Checked = bool.Parse(config.ReadConfigFile("ip7IsEnable"));
            textBox8.Text = config.ReadConfigFile("ip8Address");
            textBox108.Text = config.ReadConfigFile("ip8Describe");
            checkBox8.Checked = bool.Parse(config.ReadConfigFile("ip8IsEnable"));
            textBox9.Text = config.ReadConfigFile("ip9Address");
            textBox109.Text = config.ReadConfigFile("ip9Describe");
            checkBox9.Checked = bool.Parse(config.ReadConfigFile("ip9IsEnable"));
            textBox10.Text = config.ReadConfigFile("ip10Address");
            textBox110.Text = config.ReadConfigFile("ip10Describe");
            checkBox10.Checked = bool.Parse(config.ReadConfigFile("ip10IsEnable"));
            textBox11.Text = config.ReadConfigFile("ip11Address");
            textBox111.Text = config.ReadConfigFile("ip11Describe");
            checkBox11.Checked = bool.Parse(config.ReadConfigFile("ip11IsEnable"));
            textBox12.Text = config.ReadConfigFile("ip12Address");
            textBox112.Text = config.ReadConfigFile("ip12Describe");
            checkBox12.Checked = bool.Parse(config.ReadConfigFile("ip12IsEnable"));
            textBox13.Text = config.ReadConfigFile("ip13Address");
            textBox113.Text = config.ReadConfigFile("ip13Describe");
            checkBox13.Checked = bool.Parse(config.ReadConfigFile("ip13IsEnable"));
            textBox14.Text = config.ReadConfigFile("ip14Address");
            textBox114.Text = config.ReadConfigFile("ip14Describe");
            checkBox14.Checked = bool.Parse(config.ReadConfigFile("ip14IsEnable"));
            textBox15.Text = config.ReadConfigFile("ip15Address");
            textBox115.Text = config.ReadConfigFile("ip15Describe");
            checkBox15.Checked = bool.Parse(config.ReadConfigFile("ip15IsEnable"));
            textBox16.Text = config.ReadConfigFile("ip16Address");
            textBox116.Text = config.ReadConfigFile("ip16Describe");
            checkBox16.Checked = bool.Parse(config.ReadConfigFile("ip16IsEnable"));
            textBox17.Text = config.ReadConfigFile("ip17Address");
            textBox117.Text = config.ReadConfigFile("ip17Describe");
            checkBox17.Checked = bool.Parse(config.ReadConfigFile("ip17IsEnable"));
            textBox18.Text = config.ReadConfigFile("ip18Address");
            textBox118.Text = config.ReadConfigFile("ip18Describe");
            checkBox18.Checked = bool.Parse(config.ReadConfigFile("ip18IsEnable"));
            textBox19.Text = config.ReadConfigFile("ip19Address");
            textBox119.Text = config.ReadConfigFile("ip19Describe");
            checkBox19.Checked = bool.Parse(config.ReadConfigFile("ip19IsEnable"));
            textBox20.Text = config.ReadConfigFile("ip20Address");
            textBox120.Text = config.ReadConfigFile("ip20Describe");
            checkBox20.Checked = bool.Parse(config.ReadConfigFile("ip20IsEnable"));
            textBox21.Text = config.ReadConfigFile("intervalTime");
            textBox22.Text = config.ReadConfigFile("equipmentName");



            #endregion


            #region  //根据ip1IsEnable选项判断是否启动新线程

            if (bool.Parse(config.ReadConfigFile("ip1IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread1));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start(); 
            }
            if (bool.Parse(config.ReadConfigFile("ip2IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread2));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip3IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread3));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip4IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread4));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip5IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread5));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip6IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread6));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip7IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread7));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip8IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread8));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip9IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread9));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip10IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread10));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip11IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread11));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip12IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread12));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip13IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread13));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip14IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread14));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip15IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread15));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip16IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread16));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip17IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread17));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip18IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread18));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip19IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread19));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            if (bool.Parse(config.ReadConfigFile("ip20IsEnable")))
            {
                Thread newThread = new Thread(new ThreadStart(PingIpThread20));//给IP地址启动一个线程来监控网络，运行的方法名是无参方法
                newThread.IsBackground = true;//设置为后台线程，那么窗体界面关闭后这个线程随之关闭
                newThread.Start();
            }
            #endregion
            DateTime afterDT = System.DateTime.Now;
            TimeSpan ts = afterDT.Subtract(beforDT);
            ReadLog("软件启动耗时： " ts.TotalMilliseconds "ms");//启动打到消息栏上
        }



        #region    //多线程方法——Ping，多线程方法不能带参数
        private void PingIpThread1()
        {
            
            PingIp1(textBox1.Text, textBox101.Text, textBox21.Text);
            
        }
        private void PingIpThread2()
        {
            PingIp2(textBox2.Text, textBox102.Text, textBox21.Text);
        }
        private void PingIpThread3()
        {
            PingIp3(textBox3.Text, textBox103.Text, textBox21.Text);
        }
        private void PingIpThread4()
        {
            PingIp4(textBox4.Text, textBox104.Text, textBox21.Text);
        }
        private void PingIpThread5()
        {
            PingIp5(textBox5.Text, textBox105.Text, textBox21.Text);
        }
        private void PingIpThread6()
        {
            PingIp6(textBox6.Text, textBox106.Text, textBox21.Text);
        }
        private void PingIpThread7()
        {
            PingIp7(textBox7.Text, textBox107.Text, textBox21.Text);
        }
        private void PingIpThread8()
        {
            PingIp8(textBox8.Text, textBox108.Text, textBox21.Text);
        }
        private void PingIpThread9()
        {
            PingIp9(textBox9.Text, textBox109.Text, textBox21.Text);
        }
        private void PingIpThread10()
        {
            PingIp10(textBox10.Text, textBox110.Text, textBox21.Text);
        }
        private void PingIpThread11()
        {
            PingIp11(textBox11.Text, textBox111.Text, textBox21.Text);
        }
        private void PingIpThread12()
        {
            PingIp12(textBox12.Text, textBox112.Text, textBox21.Text);
        }
        private void PingIpThread13()
        {
            PingIp13(textBox13.Text, textBox113.Text, textBox21.Text);
        }
        private void PingIpThread14()
        {
            PingIp14(textBox14.Text, textBox114.Text, textBox21.Text);
        }
        private void PingIpThread15()
        {
            PingIp15(textBox15.Text, textBox115.Text, textBox21.Text);
        }
        private void PingIpThread16()
        {
            PingIp16(textBox16.Text, textBox116.Text, textBox21.Text);
        }
        private void PingIpThread17()
        {
            PingIp17(textBox17.Text, textBox117.Text, textBox21.Text);
        }
        private void PingIpThread18()
        {
            PingIp18(textBox18.Text, textBox118.Text, textBox21.Text);
        }
        private void PingIpThread19()
        {
            PingIp19(textBox19.Text, textBox119.Text, textBox21.Text);
        }
        private void PingIpThread20()
        {
            PingIp20(textBox20.Text, textBox120.Text, textBox21.Text);
        }



        //中转一道，调用带参方法，其实也可以不带参数，可直接将textBox.Text用到函数内部
        private void PingIp1(string ipAds,string ipDsb,string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                DateTime beforDT = System.DateTime.Now;
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) *1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label101.ForeColor = Color.Green;
                            label101.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("1号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label101.ForeColor = Color.Red;
                            label101.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("1号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("1号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label101.ForeColor = Color.Red;
                        label101.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("1号ip " ipDsb " Ping不通！" ex.ToString());
                }
                DateTime afterDT = System.DateTime.Now;
                TimeSpan ts = afterDT.Subtract(beforDT);
                this.Invoke(new Action(() =>
                {
                    ReadLog("1号ping耗时： " ts.TotalMilliseconds "ms");//启动打到消息栏上

                }));
                
            }
        }

        private void PingIp2(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label102.ForeColor = Color.Green;
                            label102.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("2号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label102.ForeColor = Color.Red;
                            label102.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("2号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("2号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label102.ForeColor = Color.Red;
                        label102.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("2号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp3(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label103.ForeColor = Color.Green;
                            label103.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("3号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label103.ForeColor = Color.Red;
                            label103.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("3号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("3号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label103.ForeColor = Color.Red;
                        label103.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("3号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp4(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label104.ForeColor = Color.Green;
                            label104.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("4号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label104.ForeColor = Color.Red;
                            label104.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("4号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("4号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label104.ForeColor = Color.Red;
                        label104.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("4号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp5(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label105.ForeColor = Color.Green;
                            label105.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("5号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label105.ForeColor = Color.Red;
                            label105.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("5号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("5号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label105.ForeColor = Color.Red;
                        label105.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("5号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp6(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label106.ForeColor = Color.Green;
                            label106.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("6号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label106.ForeColor = Color.Red;
                            label106.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("6号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("6号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label106.ForeColor = Color.Red;
                        label106.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("6号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp7(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label107.ForeColor = Color.Green;
                            label107.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("7号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label107.ForeColor = Color.Red;
                            label107.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("7号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("7号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label107.ForeColor = Color.Red;
                        label107.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("7号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp8(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label108.ForeColor = Color.Green;
                            label108.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("8号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label108.ForeColor = Color.Red;
                            label108.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("8号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("8号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label108.ForeColor = Color.Red;
                        label108.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("8号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp9(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label109.ForeColor = Color.Green;
                            label109.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("9号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label109.ForeColor = Color.Red;
                            label109.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("9号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("9号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label109.ForeColor = Color.Red;
                        label109.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("9号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp10(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label110.ForeColor = Color.Green;
                            label110.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("10号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label110.ForeColor = Color.Red;
                            label110.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("10号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("10号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label110.ForeColor = Color.Red;
                        label110.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("10号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp11(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label111.ForeColor = Color.Green;
                            label111.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("11号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label111.ForeColor = Color.Red;
                            label111.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("11号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("11号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label111.ForeColor = Color.Red;
                        label111.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("11号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp12(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label112.ForeColor = Color.Green;
                            label112.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("12号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label112.ForeColor = Color.Red;
                            label112.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("12号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("12号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label112.ForeColor = Color.Red;
                        label112.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("12号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp13(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label113.ForeColor = Color.Green;
                            label113.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("13号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label113.ForeColor = Color.Red;
                            label113.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("13号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("13号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label113.ForeColor = Color.Red;
                        label113.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("13号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp14(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label114.ForeColor = Color.Green;
                            label114.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("14号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label114.ForeColor = Color.Red;
                            label114.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("14号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("14号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label114.ForeColor = Color.Red;
                        label114.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("14号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp15(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label115.ForeColor = Color.Green;
                            label115.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("15号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label115.ForeColor = Color.Red;
                            label115.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("15号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("15号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label115.ForeColor = Color.Red;
                        label115.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("15号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp16(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label116.ForeColor = Color.Green;
                            label116.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("16号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label116.ForeColor = Color.Red;
                            label116.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("16号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("16号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label116.ForeColor = Color.Red;
                        label116.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("16号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp17(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label117.ForeColor = Color.Green;
                            label117.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("17号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label117.ForeColor = Color.Red;
                            label117.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("17号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("17号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label117.ForeColor = Color.Red;
                        label117.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("17号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp18(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label118.ForeColor = Color.Green;
                            label118.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("18号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label118.ForeColor = Color.Red;
                            label118.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("18号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("18号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label118.ForeColor = Color.Red;
                        label118.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("18号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp19(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label119.ForeColor = Color.Green;
                            label119.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("19号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label119.ForeColor = Color.Red;
                            label119.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("19号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("19号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label119.ForeColor = Color.Red;
                        label119.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("19号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }

        private void PingIp20(string ipAds, string ipDsb, string intervalTime)
        {

            //构造Ping实例
            Ping ping = new Ping();
            //Ping 选项设置
            PingOptions options = new PingOptions();
            options.DontFragment = true;
            //测试数据
            string data = "";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            //设置超时时间
            int timeout = 120;
            //轮询
            while (true)
            {
                try
                {
                    Thread.Sleep(int.Parse(intervalTime) * 1000);//按设置的间隔时间，周期性ping

                    //调用同步 send 方法发送数据,将返回结果保存至PingReply实例
                    PingReply reply = ping.Send(ipAds, timeout, buffer, options);
                    if (reply.Status == IPStatus.Success)
                    {
                        this.Invoke(new Action(() =>
                        {
                            label101.ForeColor = Color.Green;
                            label101.Text = "连接正常";
                        }));
                    }
                    else
                    {
                        //跨线程调用控件，
                        this.Invoke(new Action(() =>
                        {
                            ReadLog2("20号ip " ipDsb " Ping不通！");//ping不成功，则打到消息栏上
                            label120.ForeColor = Color.Red;
                            label120.Text = "连接不正常";//ping不成功，则修改状态
                        }));
                        //CLog.WriteErrLog("20号ip " ipDsb " Ping不通！");
                    }
                }
                catch (Exception ex)
                {
                    this.Invoke(new Action(() =>
                    {
                        ReadLog2("20号ip " ipDsb " Ping不通！" ex.ToString());//代码报错，则打到消息栏上
                        label120.ForeColor = Color.Red;
                        label120.Text = "连接不正常";//ping不成功，则修改状态
                    }));
                    //CLog.WriteErrLog("20号ip " ipDsb " Ping不通！" ex.ToString());
                }
            }
        }



        #endregion


        #region    //消息打印到richTextBox1
        /// <summary>
        /// 将日志消息显示在Form1的richTextBox1控件上,供所有类调用,黑色字体
        /// </summary>
        /// <param name="message"></param>
        public void ReadLog(string message)
        {
            string Time = Convert.ToString(DateTime.Now);
            richTextBox1.SelectionColor = Color.Black;
            richTextBox1.AppendText(Time "  " message "\n");//这样写总是在最下方添加
            richTextBox1.ScrollToCaret();//光标滚到最后一行
        }

        /// <summary>
        /// 将日志消息显示在Form1的richTextBox1控件上,供所有类调用，红色字体
        /// </summary>
        /// <param name="message"></param>
        public void ReadLog2(string message)
        {
            string Time = Convert.ToString(DateTime.Now);
            richTextBox1.SelectionColor = Color.Red;
            richTextBox1.AppendText(Time "  " message "\n");//这样写总是在最下方添加
            richTextBox1.ScrollToCaret();//光标滚到最后一行
        }


        /// <summary>
        /// 控制richTeztBox1的显示行数，并删除超出10000行数并保持剩余行颜色不变，同时始终保证滚动条和光标在最后一行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void richTextBox1_TextChanged(object sender, EventArgs e)
        {
            if (richTextBox1.Lines.Length > 10000)
            {
                richTextBox1.SelectionStart = 0;
                richTextBox1.SelectionLength = richTextBox1.GetFirstCharIndexFromLine(1);
                richTextBox1.SelectedText = "...";//如果赋空字符串就不能正常删除超出的行，也不能保留颜色，必须给点什么
                //光标聚焦在最后一行
                richTextBox1.Select(richTextBox1.Text.Length, 0);
                richTextBox1.ScrollToCaret();

            }
        }
        #endregion


        #region   //确认修改按钮
        private void button1_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip1Address", textBox1.Text);
            config.WriteConfigFile("ip1Describe", textBox101.Text);
            config.WriteConfigFile("ip1IsEnable", checkBox1.Checked.ToString());

        }

        private void button2_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip2Address", textBox2.Text);
            config.WriteConfigFile("ip2Describe", textBox102.Text);
            config.WriteConfigFile("ip2IsEnable", checkBox2.Checked.ToString());
        }

        private void button3_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip3Address", textBox3.Text);
            config.WriteConfigFile("ip3Describe", textBox103.Text);
            config.WriteConfigFile("ip3IsEnable", checkBox3.Checked.ToString());
        }

        private void button4_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip4Address", textBox4.Text);
            config.WriteConfigFile("ip4Describe", textBox104.Text);
            config.WriteConfigFile("ip4IsEnable", checkBox4.Checked.ToString());
        }

        private void button5_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip5Address", textBox5.Text);
            config.WriteConfigFile("ip5Describe", textBox105.Text);
            config.WriteConfigFile("ip5IsEnable", checkBox5.Checked.ToString());
        }

        private void button6_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip6Address", textBox6.Text);
            config.WriteConfigFile("ip6Describe", textBox106.Text);
            config.WriteConfigFile("ip6IsEnable", checkBox6.Checked.ToString());
        }

        private void button7_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip7Address", textBox7.Text);
            config.WriteConfigFile("ip7Describe", textBox107.Text);
            config.WriteConfigFile("ip7IsEnable", checkBox7.Checked.ToString());
        }

        private void button8_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip8Address", textBox8.Text);
            config.WriteConfigFile("ip8Describe", textBox108.Text);
            config.WriteConfigFile("ip8IsEnable", checkBox8.Checked.ToString());
        }

        private void button9_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip9Address", textBox9.Text);
            config.WriteConfigFile("ip9Describe", textBox109.Text);
            config.WriteConfigFile("ip9IsEnable", checkBox9.Checked.ToString());
        }

        private void button10_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip10Address", textBox10.Text);
            config.WriteConfigFile("ip10Describe", textBox110.Text);
            config.WriteConfigFile("ip10IsEnable", checkBox10.Checked.ToString());
        }

        private void button11_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip11Address", textBox11.Text);
            config.WriteConfigFile("ip11Describe", textBox111.Text);
            config.WriteConfigFile("ip11IsEnable", checkBox11.Checked.ToString());
        }

        private void button12_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip12Address", textBox12.Text);
            config.WriteConfigFile("ip12Describe", textBox112.Text);
            config.WriteConfigFile("ip12IsEnable", checkBox12.Checked.ToString());
        }

        private void button13_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip13Address", textBox13.Text);
            config.WriteConfigFile("ip13Describe", textBox113.Text);
            config.WriteConfigFile("ip13IsEnable", checkBox13.Checked.ToString());
        }

        private void button14_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip14Address", textBox14.Text);
            config.WriteConfigFile("ip14Describe", textBox114.Text);
            config.WriteConfigFile("ip14IsEnable", checkBox14.Checked.ToString());
        }

        private void button15_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip15Address", textBox15.Text);
            config.WriteConfigFile("ip15Describe", textBox115.Text);
            config.WriteConfigFile("ip15IsEnable", checkBox15.Checked.ToString());
        }

        private void button16_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip16Address", textBox16.Text);
            config.WriteConfigFile("ip16Describe", textBox116.Text);
            config.WriteConfigFile("ip16IsEnable", checkBox16.Checked.ToString());
        }

        private void button17_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip17Address", textBox17.Text);
            config.WriteConfigFile("ip17Describe", textBox117.Text);
            config.WriteConfigFile("ip17IsEnable", checkBox17.Checked.ToString());
        }

        private void button18_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip18Address", textBox18.Text);
            config.WriteConfigFile("ip18Describe", textBox118.Text);
            config.WriteConfigFile("ip18IsEnable", checkBox18.Checked.ToString());
        }

        private void button19_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip19Address", textBox19.Text);
            config.WriteConfigFile("ip19Describe", textBox119.Text);
            config.WriteConfigFile("ip19IsEnable", checkBox19.Checked.ToString());
        }

        private void button20_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("ip20Address", textBox20.Text);
            config.WriteConfigFile("ip20Describe", textBox120.Text);
            config.WriteConfigFile("ip20IsEnable", checkBox20.Checked.ToString());
        }

        private void button22_Click(object sender, EventArgs e)
        {
            config.WriteConfigFile("intervalTime", textBox21.Text);
            config.WriteConfigFile("equipmentName", textBox22.Text);
        }

        #endregion


        /// <summary>
        /// 配置刷新按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button21_Click(object sender, EventArgs e)
        {
            #region  //读取配置文件信息

            textBox1.Text = config.ReadConfigFile("ip1Address");
            textBox101.Text = config.ReadConfigFile("ip1Describe");
            checkBox1.Checked = bool.Parse(config.ReadConfigFile("ip1IsEnable"));
            textBox2.Text = config.ReadConfigFile("ip2Address");
            textBox102.Text = config.ReadConfigFile("ip2Describe");
            checkBox2.Checked = bool.Parse(config.ReadConfigFile("ip2IsEnable"));
            textBox3.Text = config.ReadConfigFile("ip3Address");
            textBox103.Text = config.ReadConfigFile("ip3Describe");
            checkBox3.Checked = bool.Parse(config.ReadConfigFile("ip3IsEnable"));
            textBox4.Text = config.ReadConfigFile("ip4Address");
            textBox104.Text = config.ReadConfigFile("ip4Describe");
            checkBox4.Checked = bool.Parse(config.ReadConfigFile("ip4IsEnable"));
            textBox5.Text = config.ReadConfigFile("ip5Address");
            textBox105.Text = config.ReadConfigFile("ip5Describe");
            checkBox5.Checked = bool.Parse(config.ReadConfigFile("ip5IsEnable"));
            textBox6.Text = config.ReadConfigFile("ip6Address");
            textBox106.Text = config.ReadConfigFile("ip6Describe");
            checkBox6.Checked = bool.Parse(config.ReadConfigFile("ip6IsEnable"));
            textBox7.Text = config.ReadConfigFile("ip7Address");
            textBox107.Text = config.ReadConfigFile("ip7Describe");
            checkBox7.Checked = bool.Parse(config.ReadConfigFile("ip7IsEnable"));
            textBox8.Text = config.ReadConfigFile("ip8Address");
            textBox108.Text = config.ReadConfigFile("ip8Describe");
            checkBox8.Checked = bool.Parse(config.ReadConfigFile("ip8IsEnable"));
            textBox9.Text = config.ReadConfigFile("ip9Address");
            textBox109.Text = config.ReadConfigFile("ip9Describe");
            checkBox9.Checked = bool.Parse(config.ReadConfigFile("ip9IsEnable"));
            textBox10.Text = config.ReadConfigFile("ip10Address");
            textBox110.Text = config.ReadConfigFile("ip10Describe");
            checkBox10.Checked = bool.Parse(config.ReadConfigFile("ip10IsEnable"));
            textBox11.Text = config.ReadConfigFile("ip11Address");
            textBox111.Text = config.ReadConfigFile("ip11Describe");
            checkBox11.Checked = bool.Parse(config.ReadConfigFile("ip11IsEnable"));
            textBox12.Text = config.ReadConfigFile("ip12Address");
            textBox112.Text = config.ReadConfigFile("ip12Describe");
            checkBox12.Checked = bool.Parse(config.ReadConfigFile("ip12IsEnable"));
            textBox13.Text = config.ReadConfigFile("ip13Address");
            textBox113.Text = config.ReadConfigFile("ip13Describe");
            checkBox13.Checked = bool.Parse(config.ReadConfigFile("ip13IsEnable"));
            textBox14.Text = config.ReadConfigFile("ip14Address");
            textBox114.Text = config.ReadConfigFile("ip14Describe");
            checkBox14.Checked = bool.Parse(config.ReadConfigFile("ip14IsEnable"));
            textBox15.Text = config.ReadConfigFile("ip15Address");
            textBox115.Text = config.ReadConfigFile("ip15Describe");
            checkBox15.Checked = bool.Parse(config.ReadConfigFile("ip15IsEnable"));
            textBox16.Text = config.ReadConfigFile("ip16Address");
            textBox116.Text = config.ReadConfigFile("ip16Describe");
            checkBox16.Checked = bool.Parse(config.ReadConfigFile("ip16IsEnable"));
            textBox17.Text = config.ReadConfigFile("ip17Address");
            textBox117.Text = config.ReadConfigFile("ip17Describe");
            checkBox17.Checked = bool.Parse(config.ReadConfigFile("ip17IsEnable"));
            textBox18.Text = config.ReadConfigFile("ip18Address");
            textBox118.Text = config.ReadConfigFile("ip18Describe");
            checkBox18.Checked = bool.Parse(config.ReadConfigFile("ip18IsEnable"));
            textBox19.Text = config.ReadConfigFile("ip19Address");
            textBox119.Text = config.ReadConfigFile("ip19Describe");
            checkBox19.Checked = bool.Parse(config.ReadConfigFile("ip19IsEnable"));
            textBox20.Text = config.ReadConfigFile("ip20Address");
            textBox120.Text = config.ReadConfigFile("ip20Describe");
            checkBox20.Checked = bool.Parse(config.ReadConfigFile("ip20IsEnable"));
            textBox21.Text = config.ReadConfigFile("intervalTime");
            textBox22.Text = config.ReadConfigFile("equipmentName");



            #endregion

        }


        /// <summary>
        /// 修改使能按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button23_Click(object sender, EventArgs e)
        {
            if (groupBox1.Enabled)
            {
                groupBox1.Enabled = false;
                button23.Text = "修改使能";
            }
            else
            {
                groupBox1.Enabled = true;
                button23.Text = "修改禁止";

            }
        }


        /// <summary>
        /// 软件关闭时确认
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            //Form1关闭时,弹窗提示，防止误关
            DialogResult TS = MessageBox.Show("确定退出？", "警告", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
            if (TS == DialogResult.Yes)
                e.Cancel = false;
            else
                e.Cancel = true;
        }


    }
}