在C#中调用API获取网络信息和流量

开发者在线 Builder.com.cn 更新时间:2007-12-20作者：lc_mtt 来源:CSDN

本文关键词： 流量 网络信息 获取 API 调用 C#

最近一项目中要求显示网络流量，而且必须使用C#。

事实上，调用 IpHlpApi.dll 的 GetIfTable API 可以轻易获得网络信息和网络流量。只是要在C#中实现还是比较复杂。

先看看怎么定义该 API [DllImport("IpHlpApi.dll")]
        extern static public uint GetIfTable(byte[] pIfTable, ref uint pdwSize, bool bOrder);
本来想把 pIfTable 定义为 IntPtr，但是这样的结果是，获取的信息是错误的（直到现在都不知是什么原因）。

但显然定义为 byte[] 是不能直接使用的。幸好在 Google Code Search 找到了三个类：

CustomtMarshaler.cs
using System;
using System.IO;
using System.Collections;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;

namespace Lemony.SystemInfo
{
    
    /**//// 

    /// CustomMarshaler class implementation.
    /// 

    public abstract class CustomMarshaler
    {
        Fields#region Fields
        // The internal buffer
        internal byte[] data;
        private MemoryStream stream;
        private BinaryReader binReader;
        private BinaryWriter binWriter;
        
        #endregion
    
        constructors#region constructors

        public CustomMarshaler()
        {

        }
        
        #endregion

        public methods#region public methods

        public void Deserialize()
        {
            if (data != null)
            {
                if (binReader != null)
                {
                    binReader.Close();
                    stream.Close();
                }
                // Create a steam from byte array
                stream = new MemoryStream(data);
                binReader = new BinaryReader(stream, System.Text.Encoding.Unicode);
                ReadFromStream(binReader);
                binReader.Close();
            }

        }

        public void Serialize()
        {
            if (data != null)
            {
                stream = new MemoryStream(data);
                binWriter = new BinaryWriter(stream, System.Text.Encoding.Unicode);
                WriteToStream(binWriter);
                binWriter.Close();
            }
        }

        public int GetSize()
        {    
            int size = 0;

            FieldInfo[] fields = this.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);

            foreach (FieldInfo field in fields )
            {
                if (field.FieldType.IsArray)
                {
                    size += GetFieldSize(field);
                }
                else if (field.FieldType == typeof(string))
                {
                    size += GetFieldSize(field)*2;
                } 
                else if (field.FieldType.IsPrimitive)
                {
                    size += Marshal.SizeOf(field.FieldType);
                }
            }

            return size;
        }

        #endregion

        properties#region properties

        public byte[] ByteArray
        {
            get
            {
                return data;
            }
        }

        #endregion

        virtual and protected methods#region virtual and protected methods

        public virtual void ReadFromStream(BinaryReader reader)
        {
            object[] param = null;

            // Get all public fields
            FieldInfo[] fields = this.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
            
            // Loop through the fields
            foreach(FieldInfo field in fields)
            {
                // Retrieve the read method from ReadMethods hashtable
                MethodInfo method = (MethodInfo)MarshallingMethods.ReadMethods[field.FieldType];

                if (field.FieldType.IsArray)
                {
                    Type element = field.FieldType.GetElementType();
                    if (element.IsValueType && element.IsPrimitive)
                    {
                        if ((element == typeof(char)) || element == typeof(byte))
                        {                                                                                 
                            param = new object[1];
                            param[0] = GetFieldSize(field);
                            field.SetValue(this, method.Invoke(reader, param)); 
                        }
                        else // any other value type array
                        {
                            param = new object[2];
                            param[0] = reader;
                            param[1] = GetFieldSize(field);
                            field.SetValue(this, method.Invoke(null, param)); 
                        }
                    }
                    else // array of sub structures
                    {
                        int size = GetFieldSize(field);
                        method = (MethodInfo)MarshallingMethods.ReadMethods[typeof(CustomMarshaler)];
                        Array objArray = Array.CreateInstance(element, size);
                        for(int i=0;i                        {
                            objArray.SetValue(Activator.CreateInstance(element), i);
                            method.Invoke(objArray.GetValue(i), new object[]);
                        }
                        field.SetValue(this, objArray); 
                    }
                }
                else if (field.FieldType == typeof(string))
                {    
                    param = new object[2];
                    param[0] = reader;
                    param[1] = GetFieldSize(field);
                    field.SetValue(this, method.Invoke(null, param)); 
                }
                else if (field.FieldType.IsValueType && field.FieldType.IsPrimitive)// regular value type
                {
                    field.SetValue(this, method.Invoke(reader, null)); 
                }
                else //process substructure 
                {
                    CustomMarshaler subStruct = (CustomMarshaler)Activator.CreateInstance(field.FieldType);
                    subStruct.ReadFromStream(reader);
                }
            }
        }

        public virtual void WriteToStream(BinaryWriter writer)
        {
            object[] param = null;

            FieldInfo[] fields = this.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
            
            foreach(FieldInfo field in fields)
            {
                // Check if we have any value
                object value = field.GetValue(this);
                
                MethodInfo method = (MethodInfo)MarshallingMethods.WriteMethods[field.FieldType];
                
                if (field.FieldType.IsArray)
                {
                    Type element = field.FieldType.GetElementType();
                    if (element.IsValueType && element.IsPrimitive)
                    {
                        //method.Invoke(writer, new object[] );
                        Array arrObject = (Array)field.GetValue(this);
                        param = new object[2];
                        param[0] = writer;
                        param[1] = arrObject;
                        method.Invoke(null, param);
                    }
                    else
                    {
                        //Get field size
                        int size = GetFieldSize(field);
                        //Get WriteToStream method
                        method = (MethodInfo)MarshallingMethods.WriteMethods[typeof(CustomMarshaler)];
                        Array arrObject = (Array)field.GetValue(this);
                        for(int i=0;i                        {
                            method.Invoke(arrObject.GetValue(i), new object[]);
                        }
                    }                    
                }
                else if (field.FieldType == typeof(string))
                {    
                    param = new object[3];
                    param[0] = writer;
                    param[1] = field.GetValue(this);
                    param[2] = GetFieldSize(field);
                    method.Invoke(null, param);
                    

                }
                else if (field.FieldType.IsValueType && field.FieldType.IsPrimitive)// regular value type
                {
                    method.Invoke(writer, new object[] );
                }
            }
        }

        protected int GetFieldSize(FieldInfo field)
        {
            int size = 0;
            CustomMarshalAsAttribute attrib = (CustomMarshalAsAttribute)field.GetCustomAttributes(typeof(CustomMarshalAsAttribute), true)[0];
            
            if (attrib != null)
            {
                if (attrib.SizeField != null)
                {
                    FieldInfo sizeField = this.GetType().GetField(attrib.SizeField);
                    size = (int)sizeField.GetValue(this);
                }
                else
                {
                    size = attrib.SizeConst;    
                }
            }

            return size;
        }

        #endregion

        helper methods#region helper methods

        private static bool CompareByteArrays (byte[] data1, byte[] data2)
        {
            // If both are null, they're equal
            if (data1==null && data2==null)
            {
                return true;
            }
            // If either but not both are null, they're not equal
            if (data1==null || data2==null)
            {
                return false;
            }
            if (data1.Length != data2.Length)
            {
                return false;
            }
            for (int i=0; i < data1.Length; i++)
            {
                if (data1[i] != data2[i])
                {
                    return false;
                }
            }
            return true;
        }

        #endregion

    }

    MarshallingMethods class#region MarshallingMethods class
    /**//// 

    /// MarshallingMethods class implementation.
    /// 

    public class MarshallingMethods
    {
        public static Hashtable ReadMethods = new Hashtable();
        public static Hashtable WriteMethods = new Hashtable();
        
        constructors#region constructors

        static MarshallingMethods()
        {
            // Read Methods
            ReadMethods.Add(typeof(bool), typeof(BinaryReader).GetMethod("ReadBoolean"));
            ReadMethods.Add(typeof(byte), typeof(BinaryReader).GetMethod("ReadByte"));
            ReadMethods.Add(typeof(System.SByte), typeof(BinaryReader).GetMethod("ReadSByte"));
            ReadMethods.Add(typeof(System.Single), typeof(BinaryReader).GetMethod("ReadSingle"));
            ReadMethods.Add(typeof(byte[]), typeof(BinaryReader).GetMethod("ReadBytes"));
            ReadMethods.Add(typeof(char[]), typeof(BinaryReader).GetMethod("ReadChars"));
            ReadMethods.Add(typeof(System.Int16), typeof(BinaryReader).GetMethod("ReadInt16"));
            ReadMethods.Add(typeof(System.Int32), typeof(BinaryReader).GetMethod("ReadInt32"));
            ReadMethods.Add(typeof(System.UInt16), typeof(BinaryReader).GetMethod("ReadUInt16"));
            ReadMethods.Add(typeof(System.UInt32), typeof(BinaryReader).GetMethod("ReadUInt32"));
            ReadMethods.Add(typeof(System.String), typeof(MarshallingMethods).GetMethod("ReadString"));
            ReadMethods.Add(typeof(System.DateTime), typeof(MarshallingMethods).GetMethod("ReadDateTime"));
            ReadMethods.Add(typeof(System.Int16[]), typeof(MarshallingMethods).GetMethod("ReadInt16Array"));
            ReadMethods.Add(typeof(System.Int32[]), typeof(MarshallingMethods).GetMethod("ReadInt32Array"));
            ReadMethods.Add(typeof(System.UInt16[]), typeof(MarshallingMethods).GetMethod("ReadUInt16Array"));
            ReadMethods.Add(typeof(System.UInt32[]), typeof(MarshallingMethods).GetMethod("ReadUInt32Array"));
            ReadMethods.Add(typeof(CustomMarshaler), typeof(CustomMarshaler).GetMethod("ReadFromStream"));
            //Write Methods
            WriteMethods.Add(typeof(bool), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(bool)}));
            WriteMethods.Add(typeof(byte), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(byte)}));
            WriteMethods.Add(typeof(System.SByte), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(System.SByte)}));
            WriteMethods.Add(typeof(System.Single), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(System.Single)}));
            //WriteMethods.Add(typeof(byte[]), typeof(BinaryWriter).GetMethod("Write", new Type[]));
            //WriteMethods.Add(typeof(char[]), typeof(BinaryWriter).GetMethod("Write", new Type[]));
            WriteMethods.Add(typeof(System.Int16), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(System.Int16)}));
            WriteMethods.Add(typeof(System.Int32), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(System.Int32)}));
            WriteMethods.Add(typeof(System.UInt16), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(System.UInt16)}));
            WriteMethods.Add(typeof(System.UInt32), typeof(BinaryWriter).GetMethod("Write", new Type[]{typeof(System.UInt32)}));
            WriteMethods.Add(typeof(System.String), typeof(MarshallingMethods).GetMethod("WriteString"));
            WriteMethods.Add(typeof(CustomMarshaler), typeof(CustomMarshaler).GetMethod("WriteToStream"));

            WriteMethods.Add(typeof(bool[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(bool[]) }));
            WriteMethods.Add(typeof(char[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(char[]) }));
            WriteMethods.Add(typeof(short[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(short[]) }));
            WriteMethods.Add(typeof(ushort[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(ushort[]) }));
            WriteMethods.Add(typeof(int[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(int[]) }));
            WriteMethods.Add(typeof(uint[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(uint[]) }));
            WriteMethods.Add(typeof(long[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(long[]) }));
            WriteMethods.Add(typeof(ulong[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(ulong[]) }));
            WriteMethods.Add(typeof(float[]), typeof(MarshallingMethods).GetMethod("WriteArray", new Type[] { typeof(BinaryWriter), typeof(float[]) }));

        }

        #endregion

        static helper methods#region static helper methods

        public static short[] ReadInt16Array(BinaryReader reader, int count)
        {
            short[] result = new short[count];

            for(int i=0;i            {
                result[i] = reader.ReadInt16();
            }
            return result;
        }
360docimg_501_
360docimg_502_        public static int[] ReadInt32Array(BinaryReader reader, int count)
360docimg_503_360docimg_504_        360docimg_505_{
360docimg_506_            int[] result = new int[count];
360docimg_507_
360docimg_508_            for(int i=0;i360docimg_509_360docimg_510_            360docimg_511_{
360docimg_512_                result[i] = reader.ReadInt32();
360docimg_513_            }
360docimg_514_            return result;
360docimg_515_        }
360docimg_516_
360docimg_517_        public static ushort[] ReadUInt16Array(BinaryReader reader, int count)
360docimg_518_360docimg_519_        360docimg_520_{
360docimg_521_            ushort[] result = new ushort[count];
360docimg_522_
360docimg_523_            for(int i=0;i360docimg_524_360docimg_525_            360docimg_526_{
360docimg_527_                result[i] = reader.ReadUInt16();
360docimg_528_            }
360docimg_529_            return result;
360docimg_530_        }
360docimg_531_
360docimg_532_        public static uint[] ReadUInt32Array(BinaryReader reader, int count)
360docimg_533_360docimg_534_        360docimg_535_{
360docimg_536_            uint[] result = new uint[count];
360docimg_537_
360docimg_538_            for(int i=0;i360docimg_539_360docimg_540_            360docimg_541_{
360docimg_542_                result[i] = reader.ReadUInt32();
360docimg_543_            }
360docimg_544_            return result;
360docimg_545_        }
360docimg_546_
360docimg_547_        public static string ReadString(BinaryReader reader, int count)
360docimg_548_360docimg_549_        360docimg_550_{
360docimg_551_            string result = "";
360docimg_552_            if (count == 0)
360docimg_553_360docimg_554_            360docimg_555_{
360docimg_556_                count = 255; //default    
360docimg_557_            }
360docimg_558_            char[] data = reader.ReadChars(count);
360docimg_559_
360docimg_560_            result = new string(data).TrimEnd('');
360docimg_561_            return result;
360docimg_562_        }
360docimg_563_
360docimg_564_        public static void WriteString(BinaryWriter writer, string value, int size)
360docimg_565_360docimg_566_        360docimg_567_{
360docimg_568_            if (value!=null)
360docimg_569_360docimg_570_            360docimg_571_{
360docimg_572_                byte[] bstring = System.Text.Encoding.Unicode.GetBytes(value.Substring(0, size)); 
360docimg_573_                writer.Write(bstring);
360docimg_574_            }
360docimg_575_        }
360docimg_576_
360docimg_577_        public static DateTime ReadDateTime(BinaryReader reader)
360docimg_578_360docimg_579_        360docimg_580_{
360docimg_581_            return DateTime.FromFileTime(reader.ReadInt64());
360docimg_582_        }
360docimg_583_
360docimg_584_
360docimg_585_        public static void WriteArray(BinaryWriter writer, bool[] arr)
360docimg_586_360docimg_587_        360docimg_588_{
360docimg_589_            for (int i = 0; i < arr.Length; i++)
360docimg_590_360docimg_591_            360docimg_592_{
360docimg_593_                writer.Write(arr[i]);
360docimg_594_            }
360docimg_595_        }
360docimg_596_        public static void WriteArray(BinaryWriter writer, char[] arr)
360docimg_597_360docimg_598_        360docimg_599_{
360docimg_600_            for (int i = 0; i < arr.Length; i++)
360docimg_601_360docimg_602_            360docimg_603_{
360docimg_604_                writer.Write(arr[i]);
360docimg_605_            }
360docimg_606_        }
360docimg_607_
360docimg_608_        public static void WriteArray(BinaryWriter writer, byte[] arr)
360docimg_609_360docimg_610_        360docimg_611_{
360docimg_612_            for (int i = 0; i < arr.Length; i++)
360docimg_613_360docimg_614_            360docimg_615_{
360docimg_616_                writer.Write(arr[i]);
360docimg_617_            }
360docimg_618_        }
360docimg_619_
360docimg_620_        public static void WriteArray(BinaryWriter writer, short[] arr)
360docimg_621_360docimg_622_        360docimg_623_{
360docimg_624_            for (int i = 0; i < arr.Length; i++)
360docimg_625_360docimg_626_            360docimg_627_{
360docimg_628_                writer.Write(arr[i]);
360docimg_629_            }
360docimg_630_        }
360docimg_631_        public static void WriteArray(BinaryWriter writer, ushort[] arr)
360docimg_632_360docimg_633_        360docimg_634_{
360docimg_635_            for (int i = 0; i < arr.Length; i++)
360docimg_636_360docimg_637_            360docimg_638_{
360docimg_639_                writer.Write(arr[i]);
360docimg_640_            }
360docimg_641_        }
360docimg_642_        public static void WriteArray(BinaryWriter writer, int[] arr)
360docimg_643_360docimg_644_        360docimg_645_{
360docimg_646_            for (int i = 0; i < arr.Length; i++)
360docimg_647_360docimg_648_            360docimg_649_{
360docimg_650_                writer.Write(arr[i]);
360docimg_651_            }
360docimg_652_        }
360docimg_653_        public static void WriteArray(BinaryWriter writer, uint[] arr)
360docimg_654_360docimg_655_        360docimg_656_{
360docimg_657_            for (int i = 0; i < arr.Length; i++)
360docimg_658_360docimg_659_            360docimg_660_{
360docimg_661_                writer.Write(arr[i]);
360docimg_662_            }
360docimg_663_        }
360docimg_664_        public static void WriteArray(BinaryWriter writer, long[] arr)
360docimg_665_360docimg_666_        360docimg_667_{
360docimg_668_            for (int i = 0; i < arr.Length; i++)
360docimg_669_360docimg_670_            360docimg_671_{
360docimg_672_                writer.Write(arr[i]);
360docimg_673_            }
360docimg_674_        }
360docimg_675_        public static void WriteArray(BinaryWriter writer, ulong[] arr)
360docimg_676_360docimg_677_        360docimg_678_{
360docimg_679_            for (int i = 0; i < arr.Length; i++)
360docimg_680_360docimg_681_            360docimg_682_{
360docimg_683_                writer.Write(arr[i]);
360docimg_684_            }
360docimg_685_        }
360docimg_686_        public static void WriteArray(BinaryWriter writer, float[] arr)
360docimg_687_360docimg_688_        360docimg_689_{
360docimg_690_            for (int i = 0; i < arr.Length; i++)
360docimg_691_360docimg_692_            360docimg_693_{
360docimg_694_                writer.Write(arr[i]);
360docimg_695_            }
360docimg_696_        }
360docimg_697_
360docimg_698_        public static void WriteSerializers(BinaryWriter writer, CustomMarshaler[] arr)
360docimg_699_360docimg_700_        360docimg_701_{
360docimg_702_            for (int i = 0; i < arr.Length; i++)
360docimg_703_360docimg_704_            360docimg_705_{
360docimg_706_                arr[i].WriteToStream(writer);
360docimg_707_            }
360docimg_708_        }
360docimg_709_
360docimg_710_        #endregion
360docimg_711_    }
360docimg_712_
360docimg_713_    #endregion
360docimg_714_
360docimg_715_360docimg_716_    CustomMarshalAsAttribute#region CustomMarshalAsAttribute
360docimg_717_360docimg_718_    /**//// 

360docimg_719_    /// CustomMarshalAsAttribute implementaion.
360docimg_720_    /// 

360docimg_721_    public sealed class CustomMarshalAsAttribute : Attribute
360docimg_722_360docimg_723_    360docimg_724_{
360docimg_725_        public int SizeConst = 0;
360docimg_726_        public string  SizeField = null;
360docimg_727_    }
360docimg_728_
360docimg_729_    #endregion
360docimg_730_
360docimg_731_}
360docimg_732_
360docimg_733_360docimg_734_MIB_IFROW.cs
360docimg_735_using System;
360docimg_736_using System.Collections.Generic;
360docimg_737_using System.Text;
360docimg_738_
360docimg_739_namespace Lemony.SystemInfo
360docimg_740_360docimg_741_360docimg_742_{
360docimg_743_    public class MIB_IFROW : CustomMarshaler
360docimg_744_360docimg_745_    360docimg_746_{
360docimg_747_        [CustomMarshalAs(SizeConst = MAX_INTERFACE_NAME_LEN)]
360docimg_748_        public string wszName;
360docimg_749_        public uint dwIndex; // index of the interface
360docimg_750_        public uint dwType; // type of interface
360docimg_751_        public uint dwMtu; // max transmission unit 
360docimg_752_        public uint dwSpeed; // speed of the interface 
360docimg_753_        public uint dwPhysAddrLen; // length of physical address
360docimg_754_        [CustomMarshalAs(SizeConst = MAXLEN_PHYSADDR)]
360docimg_755_        public byte[] bPhysAddr; // physical address of adapter
360docimg_756_        public uint dwAdminStatus; // administrative status
360docimg_757_        public uint dwOperStatus; // operational status
360docimg_758_        public uint dwLastChange; // last time operational status changed 
360docimg_759_        public uint dwInOctets; // octets received
360docimg_760_        public uint dwInUcastPkts; // unicast packets received 
360docimg_761_        public uint dwInNUcastPkts; // non-unicast packets received 
360docimg_762_        public uint dwInDiscards; // received packets discarded 
360docimg_763_        public uint dwInErrors; // erroneous packets received 
360docimg_764_        public uint dwInUnknownProtos; // unknown protocol packets received 
360docimg_765_        public uint dwOutOctets; // octets sent 
360docimg_766_        public uint dwOutUcastPkts; // unicast packets sent 
360docimg_767_        public uint dwOutNUcastPkts; // non-unicast packets sent 
360docimg_768_        public uint dwOutDiscards; // outgoing packets discarded 
360docimg_769_        public uint dwOutErrors; // erroneous packets sent 
360docimg_770_        public uint dwOutQLen; // output queue length 
360docimg_771_        public uint dwDescrLen; // length of bDescr member 
360docimg_772_        [CustomMarshalAs(SizeConst = MAXLEN_IFDESCR)]
360docimg_773_        public byte[] bDescr; // interface description         
360docimg_774_
360docimg_775_        private const int MAX_INTERFACE_NAME_LEN = 256;
360docimg_776_        private const int MAXLEN_PHYSADDR = 8;
360docimg_777_        private const int MAXLEN_IFDESCR = 256;
360docimg_778_        private const int MAX_ADAPTER_NAME = 128;
360docimg_779_    }
360docimg_780_}
360docimg_781_
360docimg_782_360docimg_783_MIB_IFTABLE.cs
360docimg_784_using System;
360docimg_785_using System.Collections.Generic;
360docimg_786_using System.Text;
360docimg_787_
360docimg_788_namespace Lemony.SystemInfo
360docimg_789_360docimg_790_360docimg_791_{
360docimg_792_360docimg_793_    /**//// 

360docimg_794_    /// IFTable
360docimg_795_    /// 

360docimg_796_    public class MIB_IFTABLE : CustomMarshaler
360docimg_797_360docimg_798_    360docimg_799_{
360docimg_800_        public int dwNumEntries;
360docimg_801_        [CustomMarshalAs(SizeField = "dwNumEntries")]
360docimg_802_        public MIB_IFROW[] Table;
360docimg_803_
360docimg_804_        public MIB_IFTABLE()
360docimg_805_360docimg_806_        360docimg_807_{
360docimg_808_            this.data = new byte[this.GetSize()];
360docimg_809_        }
360docimg_810_
360docimg_811_        public MIB_IFTABLE(int size)
360docimg_812_360docimg_813_        360docimg_814_{
360docimg_815_            this.data = new byte[size];
360docimg_816_        }
360docimg_817_    }
360docimg_818_}
360docimg_819_
再定义一个 NetInfo 类，存储网络信息

360docimg_820_360docimg_821_NetInfo.cs
360docimg_822_using System;
360docimg_823_using System.Collections.Generic;
360docimg_824_using System.Text;
360docimg_825_using System.Runtime.InteropServices;
360docimg_826_
360docimg_827_
360docimg_828_namespace Lemony.SystemInfo
360docimg_829_360docimg_830_360docimg_831_{
360docimg_832_360docimg_833_    /**//// 

360docimg_834_    /// 网络类型
360docimg_835_    /// 

360docimg_836_    public enum NetType
360docimg_837_360docimg_838_    360docimg_839_{
360docimg_840_        Other = 1,
360docimg_841_        Ethernet = 6,
360docimg_842_        Tokenring = 9,
360docimg_843_        FDDI = 15,
360docimg_844_        PPP = 23,
360docimg_845_        Loopback = 24,
360docimg_846_        Slip = 28
360docimg_847_    };
360docimg_848_
360docimg_849_360docimg_850_    /**//// 

360docimg_851_    /// 网络状态
360docimg_852_    /// 

360docimg_853_    public enum NetState
360docimg_854_360docimg_855_    360docimg_856_{
360docimg_857_        NotOperational = 0,
360docimg_858_        Operational = 1,
360docimg_859_        Disconnected = 2,
360docimg_860_        Connecting = 3,
360docimg_861_        Connected = 4,
360docimg_862_        Unreachable = 5
360docimg_863_    };
360docimg_864_
360docimg_865_360docimg_866_    /**//// 

360docimg_867_    /// 网络信息类
360docimg_868_    /// 

360docimg_869_    public class NetInfo
360docimg_870_360docimg_871_    360docimg_872_{
360docimg_873_        public NetInfo()
360docimg_874_360docimg_875_        360docimg_876_{
360docimg_877_        }
360docimg_878_
360docimg_879_        private string m_Name;
360docimg_880_360docimg_881_        /**//// 

360docimg_882_        /// 名称
360docimg_883_        /// 

360docimg_884_        public string Name
360docimg_885_360docimg_886_        360docimg_887_{
360docimg_888_360docimg_889_            get 360docimg_890_{ return m_Name; }
360docimg_891_360docimg_892_            set 360docimg_893_{ m_Name = value; }
360docimg_894_        }
360docimg_895_
360docimg_896_        private uint m_Index;
360docimg_897_360docimg_898_        /**//// 

360docimg_899_        /// 有效编号
360docimg_900_        /// 

360docimg_901_        public uint Index
360docimg_902_360docimg_903_        360docimg_904_{
360docimg_905_360docimg_906_            get 360docimg_907_{ return m_Index; }
360docimg_908_360docimg_909_            set 360docimg_910_{ m_Index = value; }
360docimg_911_        }
360docimg_912_
360docimg_913_        private NetType m_Type;
360docimg_914_360docimg_915_        /**//// 

360docimg_916_        /// 类型
360docimg_917_        /// 

360docimg_918_        public NetType Type
360docimg_919_360docimg_920_        360docimg_921_{
360docimg_922_360docimg_923_            get 360docimg_924_{ return m_Type; }
360docimg_925_360docimg_926_            set 360docimg_927_{ m_Type = value; }
360docimg_928_        }
360docimg_929_
360docimg_930_        private uint m_Speed;
360docimg_931_360docimg_932_        /**//// 

360docimg_933_        /// 速度
360docimg_934_        /// 

360docimg_935_        public uint Speed
360docimg_936_360docimg_937_        360docimg_938_{
360docimg_939_360docimg_940_            get 360docimg_941_{ return m_Speed; }
360docimg_942_360docimg_943_            set 360docimg_944_{ m_Speed = value; }
360docimg_945_        }
360docimg_946_
360docimg_947_        private uint m_InOctets;
360docimg_948_360docimg_949_        /**//// 

360docimg_950_        /// 总接收字节数
360docimg_951_        /// 

360docimg_952_        public uint InOctets
360docimg_953_360docimg_954_        360docimg_955_{
360docimg_956_360docimg_957_            get 360docimg_958_{ return m_InOctets; }
360docimg_959_360docimg_960_            set 360docimg_961_{ m_InOctets = value; }
360docimg_962_        }
360docimg_963_
360docimg_964_        private uint m_OutOctets;
360docimg_965_360docimg_966_        /**//// 

360docimg_967_        /// 总发送字节数
360docimg_968_        /// 

360docimg_969_        public uint OutOctets
360docimg_970_360docimg_971_        360docimg_972_{
360docimg_973_360docimg_974_            get 360docimg_975_{ return m_OutOctets; }
360docimg_976_360docimg_977_            set 360docimg_978_{ m_OutOctets = value; }
360docimg_979_        }
360docimg_980_
360docimg_981_        private NetState m_Status;
360docimg_982_360docimg_983_        /**//// 

360docimg_984_        /// 操作状态
360docimg_985_        /// 

360docimg_986_        public NetState Status
360docimg_987_360docimg_988_        360docimg_989_{
360docimg_990_360docimg_991_            get 360docimg_992_{ return m_Status; }
360docimg_993_360docimg_994_            set 360docimg_995_{ m_Status = value; }
360docimg_996_        }
360docimg_997_
360docimg_998_        private uint m_InErrors;
360docimg_999_360docimg_1000_        /**//// 

360docimg_1001_        /// 总错收字节数
360docimg_1002_        /// 

360docimg_1003_        public uint InErrors
360docimg_1004_360docimg_1005_        360docimg_1006_{
360docimg_1007_360docimg_1008_            get 360docimg_1009_{ return m_InErrors; }
360docimg_1010_360docimg_1011_            set 360docimg_1012_{ m_InErrors = value; }
360docimg_1013_        }
360docimg_1014_
360docimg_1015_        private uint m_OutErrors;
360docimg_1016_360docimg_1017_        /**//// 

360docimg_1018_        /// 总错发字节数
360docimg_1019_        /// 

360docimg_1020_        public uint OutErrors
360docimg_1021_360docimg_1022_        360docimg_1023_{
360docimg_1024_360docimg_1025_            get 360docimg_1026_{ return m_OutErrors; }
360docimg_1027_360docimg_1028_            set 360docimg_1029_{ m_OutErrors = value; }
360docimg_1030_        }
360docimg_1031_
360docimg_1032_        private uint m_InUnknownProtos;
360docimg_1033_360docimg_1034_        /**//// 

360docimg_1035_        /// 未知协议共收字节数
360docimg_1036_        /// 

360docimg_1037_        public uint InUnknownProtos
360docimg_1038_360docimg_1039_        360docimg_1040_{
360docimg_1041_360docimg_1042_            get 360docimg_1043_{ return m_InUnknownProtos; }
360docimg_1044_360docimg_1045_            set 360docimg_1046_{ m_InUnknownProtos = value; }
360docimg_1047_        }
360docimg_1048_
360docimg_1049_        private string m_PhysAddr;
360docimg_1050_360docimg_1051_        /**//// 

360docimg_1052_        /// 物理地址
360docimg_1053_        /// 

360docimg_1054_        public string PhysAddr
360docimg_1055_360docimg_1056_        360docimg_1057_{
360docimg_1058_360docimg_1059_            get 360docimg_1060_{ return m_PhysAddr; }
360docimg_1061_360docimg_1062_            set 360docimg_1063_{ m_PhysAddr = value; }
360docimg_1064_        }
360docimg_1065_
360docimg_1066_    }
360docimg_1067_}
360docimg_1068_
OK，现在可以获取网络信息了

360docimg_1069_360docimg_1070_        /**//// 

360docimg_1071_        /// Get IFTable
360docimg_1072_        /// 

360docimg_1073_        /// MIB_IFTABLE Class
360docimg_1074_        private static MIB_IFTABLE GetAllIfTable()
360docimg_1075_360docimg_1076_        360docimg_1077_{
360docimg_1078_            //缓冲区大小
360docimg_1079_            uint dwSize = 0;
360docimg_1080_
360docimg_1081_            //获取缓冲区大小
360docimg_1082_            uint ret = GetIfTable(null, ref dwSize, false);
360docimg_1083_            if (ret == 50)
360docimg_1084_360docimg_1085_            360docimg_1086_{
360docimg_1087_                //此函数仅支持于 win98/nt 系统
360docimg_1088_                return null;
360docimg_1089_            }
360docimg_1090_
360docimg_1091_            //定义，获取 MIB_IFTABLE 对象
360docimg_1092_            MIB_IFTABLE tbl = new MIB_IFTABLE((int)dwSize);
360docimg_1093_            ret = GetIfTable(tbl.ByteArray, ref dwSize, false);
360docimg_1094_
360docimg_1095_            //如果不成功
360docimg_1096_            if (ret != 0)
360docimg_1097_360docimg_1098_            360docimg_1099_{
360docimg_1100_                return null;
360docimg_1101_            }
360docimg_1102_
360docimg_1103_            return tbl;
360docimg_1104_        }
360docimg_1105_
360docimg_1106_360docimg_1107_        /**//// 

360docimg_1108_        /// Get NetInfo Class
360docimg_1109_        /// 

360docimg_1110_        /// MIB_IFROW Class
360docimg_1111_        /// NetInfo Class
360docimg_1112_        private static NetInfo GetNetInfo(MIB_IFROW row)
360docimg_1113_360docimg_1114_        360docimg_1115_{
360docimg_1116_            NetInfo ninfo = new NetInfo();
360docimg_1117_            ninfo.Index = row.dwIndex;
360docimg_1118_            ninfo.Name = Encoding.ASCII.GetString(row.bDescr, 0, (int)row.dwDescrLen);
360docimg_1119_            ninfo.PhysAddr = GetPhysAddr(row.bPhysAddr, (int)row.dwPhysAddrLen);
360docimg_1120_            ninfo.Type = (NetType)row.dwType;
360docimg_1121_            ninfo.Status = (NetState)row.dwOperStatus;
360docimg_1122_            ninfo.Speed = row.dwSpeed;
360docimg_1123_            ninfo.InErrors = row.dwInErrors;
360docimg_1124_            ninfo.InOctets = row.dwInOctets;
360docimg_1125_            ninfo.InUnknownProtos = row.dwInUnknownProtos;
360docimg_1126_            ninfo.OutErrors = row.dwOutErrors;
360docimg_1127_            ninfo.OutOctets = row.dwOutOctets;
360docimg_1128_            return ninfo;
360docimg_1129_        }
360docimg_1130_360docimg_1131_/**//// 

360docimg_1132_        /// 获取所有的网络信息
360docimg_1133_        /// 

360docimg_1134_        /// NetInfo 网络信息范型
360docimg_1135_        public static List GetAllNetInfo()
360docimg_1136_360docimg_1137_        360docimg_1138_{
360docimg_1139_            //定义范型
360docimg_1140_            List ninfos = new List();
360docimg_1141_
360docimg_1142_            //定义，获取 MIB_IFTABLE 对象
360docimg_1143_            MIB_IFTABLE tbl = GetAllIfTable();
360docimg_1144_
360docimg_1145_            //如果成功
360docimg_1146_            if (tbl != null)
360docimg_1147_360docimg_1148_            360docimg_1149_{
360docimg_1150_                tbl.Deserialize();
360docimg_1151_                for (int i = 0; i < tbl.Table.Length; i++)
360docimg_1152_360docimg_1153_                360docimg_1154_{
360docimg_1155_                    ninfos.Add(GetNetInfo(tbl.Table[i]));
360docimg_1156_                }
360docimg_1157_            }
360docimg_1158_
360docimg_1159_            return ninfos;
360docimg_1160_        }
PS：事实上，我把获取网络、CPU、内存、磁盘、进程信息等功能封装起来，并做了一个比较完善的 Windows 任务管理器，整理完后发布源码。
查看本文来源