主机性能监控系统7.获取网络性能信息(升级版)

      感谢老虎爱吃鱼同学在《主机性能监控系统--7.获取网络性能信息》提出的BUG，这个问题确实是没有注意到，因为刚好我的网卡名字中都没有包含括号，斜线等特殊符号，而且由于时间仓促，也没有去虚机里面做测试，本篇作为升级版，首先解决了(我用包含有特殊符号的网卡做了测试)老虎爱吃鱼同学提出的BUG，并且修复一些之前没看到的小BUG，继而，增加了一个功能，就是当系统中存在多张网卡的时候，可以通过下拉框选择要查看网卡的信息。OK，效果图先秀下，由于是在虚机里面的截图，所以比较丑，不过能说明事情就好了:）。

      代码上改动不大，但是，还是贴上来下比较好，哈哈，类图就没什么大变化了，就不贴了，显示NetInfo这个类的代码，如下：

 

public class NetInfo
    {
        NetPerformanceStruct netPerformanceStruct;

        //定义PerformanceCounter
        PerformanceCounter pcBytesTotal = new PerformanceCounter();
        PerformanceCounter pcBytesSent = new PerformanceCounter();
        PerformanceCounter pcBytesReceived = new PerformanceCounter();
        PerformanceCounter pcPacketsTotal = new PerformanceCounter();
        PerformanceCounter pcPacketsSent = new PerformanceCounter();
        PerformanceCounter pcPacketsSentUnicast = new PerformanceCounter();
        PerformanceCounter pcPacketsSentNonUnicast = new PerformanceCounter();
        PerformanceCounter pcPacketsSentDiscarded = new PerformanceCounter();
        PerformanceCounter pcPacketsSentErrors = new PerformanceCounter();
        PerformanceCounter pcPacketsReceived = new PerformanceCounter();
        PerformanceCounter pcPacketsReceivedUnicast = new PerformanceCounter();
        PerformanceCounter pcPacketsReceivedNonUnicast = new PerformanceCounter();
        PerformanceCounter pcPacketsReceivedDiscarded = new PerformanceCounter();
        PerformanceCounter pcPacketsReceivedErrors = new PerformanceCounter();

        //构造函数
        public NetInfo()
        {

        }


        //网络基础信息结构体
        public struct NetInfoBaseStruct
        {
            public string NetName;  //网络名称
            public string[] IPAddress;  //IP地址，包括IPv4和IPv6
            public string MACAddress;  //MAC地址
            public string IPSubnet;  //子网掩码
            public string DefaultIPGateway;  //默认网关
        }


        //网络性能结构体
        public struct NetPerformanceStruct
        {
           //字节
            public float BytesTotal;  //每秒总字节数
            public float BytesSent;  //每秒发送字节数
            public float BytesReceived;  //每秒发送字节数

           //包
            public float PacketsTotal;  //每秒总包数

            //包发送
            public float PacketsSent;  //每秒发送包数
            public float PacketsSentUnicast;  //每秒发送单播包数
            public float PacketsSentNonUnicast;  //每秒发送非单播包数
            public float PacketsSentDiscarded;  //被丢弃的发送包数
            public float PacketsSentErrors;  //错误的发送包数


           //包接收
            public float PacketsReceived;  //每秒接收包数
            public float PacketsReceivedUnicast;  //每秒接收单播包数
            public float PacketsReceivedNonUnicast;  //每秒接收非单播包数
            public float PacketsReceivedDiscarded;  //被丢弃的接收包数
            public float PacketsReceivedErrors;  //错误的接收包数



        }


        //获取网络基本信息
        /**//// <summary>
        /// 获取网络基本信息
        /// </summary>
        /// <returns>包含网络基本信息结构体的列表</returns>
        public List<NetInfoBaseStruct> GetNetInfoBase()
        {
            List<NetInfoBaseStruct> lNetInfo = new List<NetInfoBaseStruct>();
            NetInfoBaseStruct netInfoBaseStruct;


            ManagementObjectSearcher query =
                            new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'");
            ManagementObjectCollection moCollection = query.Get();

            //遍历
            foreach (ManagementObject mObject in moCollection)
            {
                try
                {
                    netInfoBaseStruct = new NetInfoBaseStruct();
                    netInfoBaseStruct.NetName = mObject["Description"].ToString();
                    netInfoBaseStruct.IPAddress = (string[])mObject["IPAddress"];
                    netInfoBaseStruct.MACAddress = mObject["MACAddress"].ToString();
                    //DefaultIPGateway
                    if (mObject["DefaultIPGateway"] == null)  //如果默认网关只有一个则返回
                    {
                        netInfoBaseStruct.DefaultIPGateway = "";
                    }
                    else   //否则返回默认网关的数组(注：这里为了简单起见，只返回第一个网关)
                    {
                        netInfoBaseStruct.DefaultIPGateway = ((string[])mObject["DefaultIPGateway"])[0];
                    }

                    //IPSubnet
                    if (mObject["IPSubnet"] == null)
                    {
                        netInfoBaseStruct.IPSubnet ="";
                    }
                    else
                    {
                        netInfoBaseStruct.IPSubnet = ((string[])mObject["IPSubnet"])[0];
                    }

                    lNetInfo.Add(netInfoBaseStruct);

                }
                catch
                {
                    //continue;
                }

            }

            return lNetInfo;
        }

        //GetNetPerformance
        public NetPerformanceStruct GetNetPerformance(string NetName)
        {

            netPerformanceStruct = new NetPerformanceStruct();

            //定义CategoryName
            pcBytesTotal.CategoryName = "Network Interface";
            pcBytesSent.CategoryName = "Network Interface";
            pcBytesReceived.CategoryName = "Network Interface";
            pcPacketsTotal.CategoryName = "Network Interface";
            pcPacketsSent.CategoryName = "Network Interface";
            pcPacketsSentUnicast.CategoryName = "Network Interface";
            pcPacketsSentNonUnicast.CategoryName = "Network Interface";
            pcPacketsSentDiscarded.CategoryName = "Network Interface";
            pcPacketsSentErrors.CategoryName = "Network Interface";
            pcPacketsReceived.CategoryName = "Network Interface";
            pcPacketsReceivedUnicast.CategoryName = "Network Interface";
            pcPacketsReceivedNonUnicast.CategoryName = "Network Interface";
            pcPacketsReceivedDiscarded.CategoryName = "Network Interface";
            pcPacketsReceivedErrors.CategoryName = "Network Interface";

            //本次改进主要部分，主要思路是通过PerformanceCounterCategory这个类来获取Network Interface下
              //的所有实例(即网卡名称)，先将这个网卡名称处理掉所有的特殊字符，然后与传递进来的网卡名称(也处理掉特殊字符)
            //进行比较，如果相同，就将符合格式的实例名称赋给网卡名称，接下去就是获取性能信息。。。
            string[] instanceNames;
            PerformanceCounterCategory mycat = new PerformanceCounterCategory("Network Interface");
            try
            {
                instanceNames = mycat.GetInstanceNames();
                string tmp;
                string tmpNormal;

                for (int i = 0; i <= instanceNames.Length; i++)
                {
                    tmp = Regex.Replace(instanceNames[i], @"[^a-zA-Z\d]", "");
                    tmpNormal = Regex.Replace(NetName, @"[^a-zA-Z\d]", "");

                    if (tmp == tmpNormal)
                    {
                        NetName = instanceNames[i];
                    }
                }
            }
            catch { }

            //定义InstanceName
            pcBytesTotal.InstanceName = NetName;
            pcBytesSent.InstanceName = NetName;
            pcBytesReceived.InstanceName = NetName;
            pcPacketsTotal.InstanceName = NetName;
            pcPacketsSent.InstanceName = NetName;
            pcPacketsSentUnicast.InstanceName = NetName;
            pcPacketsSentNonUnicast.InstanceName = NetName;
            pcPacketsSentDiscarded.InstanceName = NetName;
            pcPacketsSentErrors.InstanceName = NetName;
            pcPacketsReceived.InstanceName = NetName;
            pcPacketsReceivedUnicast.InstanceName = NetName;
            pcPacketsReceivedNonUnicast.InstanceName = NetName;
            pcPacketsReceivedDiscarded.InstanceName = NetName;
            pcPacketsReceivedErrors.InstanceName = NetName;

            //定义CounterName
            pcBytesTotal.CounterName = "Bytes Total/sec";
            pcBytesSent.CounterName = "Bytes Sent/sec";
            pcBytesReceived.CounterName = "Bytes Received/sec";
            pcPacketsTotal.CounterName = "Packets/sec";
            pcPacketsSent.CounterName = "Packets Sent/sec";
            pcPacketsSentUnicast.CounterName = "Packets Sent Unicast/sec";
            pcPacketsSentNonUnicast.CounterName = "Packets Sent Non-Unicast/sec";
            pcPacketsSentDiscarded.CounterName = "Packets Outbound Discarded";
            pcPacketsSentErrors.CounterName = "Packets Outbound Errors";
            pcPacketsReceived.CounterName = "Packets Received/sec";
            pcPacketsReceivedUnicast.CounterName = "Packets Received Unicast/sec";
            pcPacketsReceivedNonUnicast.CounterName = "Packets Received Non-Unicast/sec";
            pcPacketsReceivedDiscarded.CounterName = "Packets Received Discarded";
            pcPacketsReceivedErrors.CounterName = "Packets Received Errors";

            try
            {
                //为结构体赋值
                netPerformanceStruct.BytesTotal = pcBytesTotal.NextValue();
                netPerformanceStruct.BytesSent = pcBytesSent.NextValue();
                netPerformanceStruct.BytesReceived = pcBytesReceived.NextValue();
                netPerformanceStruct.PacketsTotal = pcPacketsTotal.NextValue();
                netPerformanceStruct.PacketsSent = pcPacketsSent.NextValue();
                netPerformanceStruct.PacketsSentUnicast = pcPacketsSentUnicast.NextValue();
                netPerformanceStruct.PacketsSentNonUnicast = pcPacketsSentNonUnicast.NextValue();
                netPerformanceStruct.PacketsSentDiscarded = pcPacketsSentDiscarded.NextValue();
                netPerformanceStruct.PacketsSentErrors = pcPacketsSentErrors.NextValue();
                netPerformanceStruct.PacketsReceived = pcPacketsReceived.NextValue();
                netPerformanceStruct.PacketsReceivedUnicast = pcPacketsReceivedUnicast.NextValue();
                netPerformanceStruct.PacketsReceivedNonUnicast = pcPacketsReceivedNonUnicast.NextValue();
                netPerformanceStruct.PacketsReceivedDiscarded = pcPacketsReceivedDiscarded.NextValue();
                netPerformanceStruct.PacketsReceivedErrors = pcPacketsReceivedErrors.NextValue();
            }
            catch
            {
                
            }

            return netPerformanceStruct;
        }
    }

 

     其中修改老虎爱吃鱼同学提出的BUG的主要代码是：

 

            //本次改进主要部分，主要思路是通过PerformanceCounterCategory这个类来获取Network Interface下
            //的所有实例(即网卡名称)，先将这个网卡名称处理掉所有的特殊字符，然后与传递进来的网卡名称(也处理掉特殊字符)
            //进行比较，如果相同，就将符合格式的实例名称赋给网卡名称，接下去就是获取性能信息。。。
            string[] instanceNames;
            PerformanceCounterCategory mycat = new PerformanceCounterCategory("Network Interface");
            try
            {
                instanceNames = mycat.GetInstanceNames();
                string tmp;
                string tmpNormal;

                for (int i = 0; i <= instanceNames.Length; i++)
                {
                    tmp = Regex.Replace(instanceNames[i], @"[^a-zA-Z\d]", "");
                    tmpNormal = Regex.Replace(NetName, @"[^a-zA-Z\d]", "");

                    if (tmp == tmpNormal)
                    {
                        NetName = instanceNames[i];
                    }
                }
            }
            catch { }

       接下来是窗体的代码：

 

    public partial class NetInfoForm : Form
    {
        public NetInfoForm()
        {
            InitializeComponent();
        }
        ComputerInfo.NetInfo netinfo = new ComputerInfo.NetInfo();
        string strNetName;
        ComputerInfo.NetInfo.NetPerformanceStruct netInfoStruct;
        List<ComputerInfo.NetInfo.NetInfoBaseStruct> lNetInfoBase;
        private void NetInfoForm_Load(object sender, EventArgs e)
        {
            //获取网络基本信息

            lNetInfoBase = netinfo.GetNetInfoBase();
            //设置ListView的样式以及列
            lvNet.View = View.Details;
            lvNet.Columns.Add("项", 150);
            lvNet.Columns.Add("值", 300);
            lvNet.FullRowSelect = true;
            lvNet.GridLines = true;

            for (int i = 0; i < lNetInfoBase.Count; i++)
            {
                cbNetCard.Items.Add(lNetInfoBase[i].NetName);
            }
      

            //设置ListView的样式以及列
            lvNetPerformance.View = View.Details;
            lvNetPerformance.Columns.Add("项", 150);
            lvNetPerformance.Columns.Add("值", 300);
            lvNetPerformance.FullRowSelect = true;
            lvNetPerformance.GridLines = true;


            cbNetCard.SelectedIndex = 0;
        }

        private void NetInfotimer_Tick(object sender, EventArgs e)
        {
            try
            {


                netInfoStruct = netinfo.GetNetPerformance(strNetName);
            }
            catch (Exception ex)
            {
                NetInfotimer.Enabled = false;
                MessageBox.Show(ex.Message + ex.StackTrace);
            }
            lvNetPerformance.Items.Clear();
            //定义一些需要用到的项
            ListViewItem lviBytesTotal = new ListViewItem(new string[] { "每秒字节总数", netInfoStruct.BytesTotal.ToString() });
            ListViewItem lviBytesSent = new ListViewItem(new string[] { "每秒发送字节数", netInfoStruct.BytesSent.ToString() });
            ListViewItem lviBytesReceived = new ListViewItem(new string[] { "每秒接收字节数", netInfoStruct.BytesReceived.ToString() });
            ListViewItem lviPacketsTotal = new ListViewItem(new string[] { "每秒包总数", netInfoStruct.PacketsTotal.ToString() });
            ListViewItem lviPacketsSent = new ListViewItem(new string[] { "每秒包发送数", netInfoStruct.PacketsSent.ToString() });
            ListViewItem lviPacketsSentUnicast = new ListViewItem(new string[] { "每秒发送单播包数", netInfoStruct.PacketsSentUnicast.ToString() });
            ListViewItem lviPacketsSentNonUnicast = new ListViewItem(new string[] { "每秒发送非单播包数", netInfoStruct.PacketsSentNonUnicast.ToString() });
            ListViewItem lviPacketsSentDiscarded = new ListViewItem(new string[] { "丢弃的发送包数", netInfoStruct.PacketsSentDiscarded.ToString() });
            ListViewItem lviPacketsSentErrors = new ListViewItem(new string[] { "错误的发送包数", netInfoStruct.PacketsSentErrors.ToString() });
            ListViewItem lviPacketsReceived = new ListViewItem(new string[] { "每秒包接收数", netInfoStruct.PacketsReceived.ToString() });
            ListViewItem lviPacketsReceivedUnicast = new ListViewItem(new string[] { "每秒单播包接收数", netInfoStruct.PacketsReceivedUnicast.ToString() });
            ListViewItem lviPacketsReceivedNonUnicast = new ListViewItem(new string[] { "每秒非单播包接收总数", netInfoStruct.PacketsReceivedNonUnicast.ToString() });
            ListViewItem lviPacketsReceivedDiscarded = new ListViewItem(new string[] { "丢弃的接收包数", netInfoStruct.PacketsReceivedDiscarded.ToString() });
            ListViewItem lviPacketsReceivedErrors = new ListViewItem(new string[] { "错误的接收包数", netInfoStruct.PacketsReceivedErrors.ToString() });


            //将项添加到ListView控件里面
            lvNetPerformance.Items.Add(lviBytesTotal);
            lvNetPerformance.Items.Add(lviBytesSent);
            lvNetPerformance.Items.Add(lviBytesReceived);
            lvNetPerformance.Items.Add(lviPacketsTotal);
            lvNetPerformance.Items.Add(lviPacketsSent);
            lvNetPerformance.Items.Add(lviPacketsSentUnicast);
            lvNetPerformance.Items.Add(lviPacketsSentNonUnicast);
            lvNetPerformance.Items.Add(lviPacketsSentDiscarded);
            lvNetPerformance.Items.Add(lviPacketsSentErrors);
            lvNetPerformance.Items.Add(lviPacketsReceived);
            lvNetPerformance.Items.Add(lviPacketsReceivedUnicast);
            lvNetPerformance.Items.Add(lviPacketsReceivedNonUnicast);
            lvNetPerformance.Items.Add(lviPacketsReceivedDiscarded);
            lvNetPerformance.Items.Add(lviPacketsReceivedErrors);




        }

        private void cbNetCard_SelectedIndexChanged(object sender, EventArgs e)
        {
            lvNet.Items.Clear();
            int nSelectindex = cbNetCard.SelectedIndex;
            strNetName = lNetInfoBase[nSelectindex].NetName;

            //定义一些需要用到的项
            ListViewItem lviNetDes = new ListViewItem(new string[] { "网卡名称", lNetInfoBase[nSelectindex].NetName });
            ListViewItem lviIPAddressV4 = new ListViewItem(new string[] { "IP地址", lNetInfoBase[0].IPAddress[nSelectindex] });
            //ListViewItem lviIPAddressV6 = new ListViewItem(new string[] { "IP地址IPV6", lNetInfoBase[0].IPAddress[1] });
            ListViewItem lviMACAddress = new ListViewItem(new string[] { "MAC地址", lNetInfoBase[nSelectindex].MACAddress });
            ListViewItem lviDefaultIPGateway = new ListViewItem(new string[] { "默认网关", lNetInfoBase[nSelectindex].DefaultIPGateway });
            ListViewItem lviIPSubnet = new ListViewItem(new string[] { "子网掩码", lNetInfoBase[nSelectindex].IPSubnet });

            //将项添加到ListView控件里面
            lvNet.Items.Add(lviNetDes);
            lvNet.Items.Add(lviIPAddressV4);
            //lvNet.Items.Add(lviIPAddressV6);
            lvNet.Items.Add(lviMACAddress);
            lvNet.Items.Add(lviDefaultIPGateway);
            lvNet.Items.Add(lviIPSubnet);

        }
    }

 

       OK，感谢各位同学提出建议，意见，以及BUG，如果您在调试过程中有遇到什么BUG的话，麻烦您跟我说下，以便把程序做好。谢谢~~~

       当然，未完，待续~~~