Перевод в vb.net - Visual Basic .NET - Ответ 4972688

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.IO;
using System.Timers;
 
namespace GetIfTableApp
{
    unsafe class Program
    {
        const int MAX_INTERFACE_NAME_LEN = 256;
        const int MAXLEN_IFDESCR = 256;
        const int ERROR_INSUFFICIENT_BUFFER = 122;
        const int NO_ERROR = 0;
        const int MAXLEN_PHYSADDR = 8;
        const int ANY_SIZE = 21;
 
        enum IANAType : uint
        {
            /// <summary>
            /// Some other type of network interface.
            /// </summary>
            IF_TYPE_OTHER = 1U,
            /// <summary>
            /// An Ethernet network interface.
            /// </summary>
            IF_TYPE_ETHERNET_CSMACD = 6U,
            /// <summary>
            /// A token ring network interface.
            /// </summary>
            IF_TYPE_ISO88025_TOKENRING = 9U,
            /// <summary>
            /// A PPP network interface.
            /// </summary>
            IF_TYPE_PPP = 23U,
            /// <summary>
            /// A software loopback network interface.
            /// </summary>
            IF_TYPE_SOFTWARE_LOOPBACK = 24U,
            /// <summary>
            /// An ATM network interface.
            /// </summary>
            IF_TYPE_ATM = 37U,
            /// <summary>
            /// An IEEE 802.11 wireless network interface.
            /// </summary>
            IF_TYPE_IEEE80211 = 71U,
            /// <summary>
            /// A tunnel type encapsulation network interface.
            /// </summary>
            IF_TYPE_TUNNEL = 131U,
            /// <summary>
            /// An IEEE 1394 (Firewire) high performance serial bus network interface.
            /// </summary>
            IF_TYPE_IEEE1394 = 144U
        }
 
        enum INTERNAL_IF_OPER_STATUS : uint
        {
            IF_OPER_STATUS_NON_OPERATIONAL = 0,
            IF_OPER_STATUS_UNREACHABLE = 1,
            IF_OPER_STATUS_DISCONNECTED = 2,
            IF_OPER_STATUS_CONNECTING = 3,
            IF_OPER_STATUS_CONNECTED = 4,
            IF_OPER_STATUS_OPERATIONAL = 5,
        }
 
        [StructLayout(LayoutKind.Sequential)]
        struct MIB_IFROW
        {
            internal fixed ushort wszName[MAX_INTERFACE_NAME_LEN];
            internal uint dwIndex;
            internal IANAType dwType;
            internal uint dwMtu;
            internal uint dwSpeed;
            internal uint dwPhysAddrLen;
            internal fixed byte bPhysAddr[MAXLEN_PHYSADDR];
            internal uint dwAdminStatus;
            internal INTERNAL_IF_OPER_STATUS dwOperStatus;
            internal uint dwLastChange;
            internal uint dwInOctets;
            internal uint dwInUcastPkts;
            internal uint dwInNUcastPkts;
            internal uint dwInDiscards;
            internal uint dwInErrors;
            internal uint dwInUnknownProtos;
            internal uint dwOutOctets;
            internal uint dwOutUcastPkts;
            internal uint dwOutNUcastPkts;
            internal uint dwOutDiscards;
            internal uint dwOutErrors;
            internal uint dwOutQLen;
            internal uint dwDescrLen;
            internal fixed byte bDescr[MAXLEN_IFDESCR];
 
            public string GetName()
            {
                fixed (ushort* pName = wszName) {
                    if (pName == null)
                        return null;
 
                    ushort* pBuff = pName;
 
                    StringBuilder sb = new StringBuilder(MAX_INTERFACE_NAME_LEN);
                    do {
                        if (*pBuff == 0)
                            break;
 
                        sb.Append((char)(*pBuff));
                        pBuff++;
                    } while (true);
                    return sb.ToString();
                }
            }
 
            public string GetDescription()
            {
                fixed (byte* pName = bDescr) {
                    if (pName == null)
                        return null;
 
                    byte* pBuff = pName;
 
                    StringBuilder sb = new StringBuilder(MAXLEN_IFDESCR);
                    do {
                        if (*pBuff == 0)
                            break;
 
                        sb.Append((char)(*pBuff));
                        pBuff++;
                    } while (true);
                    return sb.ToString();
                }
            }
 
            public string GetPhysAddr()
            {
                fixed (byte* pName = bPhysAddr) {
                    if (pName == null)
                        return null;
 
                    byte* pBuff = pName;
 
                    StringBuilder sb = new StringBuilder(MAXLEN_PHYSADDR);
                    do {
                        if (*pBuff == 0)
                            break;
 
                        sb.Append((char)(*pBuff));
                        pBuff++;
                    } while (true);
                    return sb.ToString();
                }
            }
        }
 
        [StructLayout(LayoutKind.Sequential)]
        struct MIB_IFTABLE
        {
            internal int dwNumEntries;
            internal void* table;
        }
 
        [DllImport("Iphlpapi.dll", SetLastError = true)]
        static extern int GetIfTable(
            [Out] MIB_IFTABLE* pIfTable,
            [In, Out] int* dwSize,
            [In] bool bOrder
            );
 
        static int Main(string[] args)
        {
            MIB_IFROW[] mibs;
            UnsafeGetIfTable(out mibs);
            using (StreamWriter sw = new StreamWriter("D:\\IFRows.txt")) {
                foreach (MIB_IFROW m in mibs)
                    sw.WriteLine(GetInfoFromIfRow(m));
                sw.Close();
            }
            Console.WriteLine("End write.. Press any key to end...");
            Console.ReadKey();
            return 0;
        }
 
        static void UnsafeGetIfTable(out MIB_IFROW[] mibs)
        {
            int dwSize = Marshal.SizeOf(typeof(MIB_IFTABLE));
            MIB_IFTABLE* pMibIfTable = (MIB_IFTABLE*)Marshal.AllocHGlobal(dwSize).ToPointer();
 
            if (GetIfTable(pMibIfTable, &dwSize, false) == ERROR_INSUFFICIENT_BUFFER) {
                Marshal.FreeHGlobal((IntPtr)pMibIfTable);
                pMibIfTable = (MIB_IFTABLE*)Marshal.AllocHGlobal(dwSize).ToPointer();
            }
 
            int dwRetVal;
            mibs = null;
            if ((dwRetVal = GetIfTable(pMibIfTable, &dwSize, true)) == NO_ERROR) {
                mibs = new MIB_IFROW[pMibIfTable->dwNumEntries];
                fixed (MIB_IFROW* pMibs = mibs) {
                    uint rowSize = (uint)Marshal.SizeOf(typeof(MIB_IFROW));
                    MIB_IFROW* pBuff = pMibs;
                    uint pTable = (uint)&pMibIfTable->table;
                    for (int i = 0; i < pMibIfTable->dwNumEntries; i++) {
                        *(pBuff++) = *(MIB_IFROW*)(pTable);
                        pTable += rowSize;
                    }
                }
            }
 
            if (pMibIfTable != null) {
                Marshal.FreeHGlobal((IntPtr)pMibIfTable);
                pMibIfTable = null;
            }
        }
 
        static string GetInfoFromIfRow(MIB_IFROW ifRow)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.AppendLine(string.Format("Индекс: {0}", ifRow.dwIndex));
            sb.AppendLine(string.Format("Имя интерфейса: {0}", ifRow.GetName()));
            sb.AppendLine(string.Format("Описание: {0}", ifRow.GetDescription()));
            sb.AppendLine(string.Format("Тип: {0}", ifRow.dwType));
            sb.AppendLine(string.Format("Maximum Transmission Unit: {0}", ifRow.dwMtu));
            sb.AppendLine(string.Format("Скорость: {0} Мбит/сек", ifRow.dwSpeed / 1024 / 1024));
            sb.AppendLine(string.Format("Физический адрес адаптера для интерфейса: {0}", ifRow.GetPhysAddr()));
            sb.AppendLine(string.Format("Admin Status: {0}", Convert.ToBoolean(ifRow.dwAdminStatus)));
            sb.AppendLine(string.Format("Oper Status: {0}", ifRow.dwOperStatus));
            sb.AppendLine("---------");
            sb.AppendLine(string.Format("dwInDiscards: {0}", ifRow.dwInDiscards));
            sb.AppendLine(string.Format("dwInErrors: {0}", ifRow.dwInErrors));
            sb.AppendLine(string.Format("dwInNUcastPkts: {0}", ifRow.dwInNUcastPkts));
            sb.AppendLine(string.Format("dwInOctets: {0}", ifRow.dwInOctets));
            sb.AppendLine(string.Format("dwInUcastPkts: {0}", ifRow.dwInUcastPkts));
            sb.AppendLine(string.Format("dwInUnknownProtos: {0}", ifRow.dwInUnknownProtos));
            sb.AppendLine(string.Format("dwOutDiscards: {0}", ifRow.dwOutDiscards));
            sb.AppendLine(string.Format("dwOutErrors: {0}", ifRow.dwOutErrors));
            sb.AppendLine(string.Format("dwOutNUcastPkts: {0}", ifRow.dwOutNUcastPkts));
            sb.AppendLine(string.Format("dwOutOctets: {0}", ifRow.dwOutOctets));
            sb.AppendLine(string.Format("dwOutQLen: {0}", ifRow.dwOutQLen));
            sb.AppendLine(string.Format("dwOutUcastPkts: {0}", ifRow.dwOutUcastPkts));
            return sb.ToString();
        }
    }
}