.net - comandos - obtener mac address windows

Lea la dirección MAC desde el adaptador de red en.NET

Question

Me gustaría poder leer la dirección MAC desde el primer adaptador de red activo usando VB.net o C # (usando .NET 3.5 SP1) para una aplicación winform

Answer 1

Aquí hay una clase para hacer eso:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace MacAddress
{
    class MacAddress
    {
        byte[] _address;

        public MacAddress(byte[] b)
        {
            if (b == null)
                throw new ArgumentNullException("b");
            if (b.Length != 8)
                throw new ArgumentOutOfRangeException("b");
            _address = new byte[b.Length];
            Array.Copy(b, _address, b.Length);
        }

        public byte[] Address { get { return _address; } }

        public override string ToString()
        {
            return Address[0].ToString("X2", System.Globalization.CultureInfo.InvariantCulture) + ":" +
                    Address[1].ToString("X2", System.Globalization.CultureInfo.InvariantCulture) + ":" +
                    Address[2].ToString("X2", System.Globalization.CultureInfo.InvariantCulture) + ":" +
                    Address[3].ToString("X2", System.Globalization.CultureInfo.InvariantCulture) + ":" +
                    Address[4].ToString("X2", System.Globalization.CultureInfo.InvariantCulture) + ":" +
                    Address[5].ToString("X2", System.Globalization.CultureInfo.InvariantCulture);
        }

        public static List<MacAddress> GetMacAddresses()
        {
            int size = 0;
            // this chunk of code teases out the first adapter info
            int r = GetAdaptersInfo(null, ref size);
            if ((r != IPConfigConst.ERROR_SUCCESS) && (r != IPConfigConst.ERROR_BUFFER_OVERFLOW))
            {
                return null;
            }
            Byte[] buffer = new Byte[size];
            r = GetAdaptersInfo(buffer, ref size);
            if (r != IPConfigConst.ERROR_SUCCESS)
            {
                return null;
            }
            AdapterInfo Adapter = new AdapterInfo();
            ByteArray_To_IPAdapterInfo(ref Adapter, buffer, Marshal.SizeOf(Adapter));

            List<MacAddress> addresses = new List<MacAddress>();
            do
            {
                addresses.Add(new MacAddress(Adapter.Address));
                IntPtr p = Adapter.NextPointer;
                if (p != IntPtr.Zero)
                {
                    IntPtr_To_IPAdapterInfo(ref Adapter, p, Marshal.SizeOf(Adapter));
                }
                else
                {
                    break;
                }
            } while (true);
            return addresses;
        }

        // glue definitions into windows
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct IPAddrString
        {
            public IntPtr NextPointer;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4 * 4)]
            public String IPAddressString;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4 * 4)]
            public String IPMaskString;
            public int Context;
        }

        private class IPConfigConst
        {
            public const int MAX_ADAPTER_DESCRIPTION_LENGTH = 128;
            public const int MAX_ADAPTER_NAME_LENGTH = 256;
            public const int MAX_ADAPTER_ADDRESS_LENGTH = 8;
            public const int ERROR_BUFFER_OVERFLOW = 111;
            public const int ERROR_SUCCESS = 0;
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        private struct AdapterInfo
        {
            public IntPtr NextPointer;
            public int ComboIndex;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = IPConfigConst.MAX_ADAPTER_NAME_LENGTH + 4)]
            public string AdapterName;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = IPConfigConst.MAX_ADAPTER_DESCRIPTION_LENGTH + 4)]
            public string Description;
            public int AddressLength;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = IPConfigConst.MAX_ADAPTER_ADDRESS_LENGTH)]
            public Byte[] Address;
            public int Index;
            public int Type;
            public int DhcpEnabled;
            public IntPtr CurrentIPAddress;
            public IPAddrString IPAddressList;
            public IPAddrString GatewayList;
            public IPAddrString DhcpServer;
            public Boolean HaveWins;
            public IPAddrString PrimaryWinsServer;
            public IPAddrString SecondaryWinsServer;
            public int LeaseObtained;
            public int LeaseExpires;
        }
        [DllImport("Iphlpapi.dll", CharSet = CharSet.Auto)]
        private static extern int GetAdaptersInfo(Byte[] PAdapterInfoBuffer, ref int size);
        [DllImport("Kernel32.dll", EntryPoint = "CopyMemory")]
        private static extern void ByteArray_To_IPAdapterInfo(ref AdapterInfo dst, Byte[] src, int size);
        [DllImport("Kernel32.dll", EntryPoint = "CopyMemory")]
        private static extern void IntPtr_To_IPAdapterInfo(ref AdapterInfo dst, IntPtr src, int size);
    }
}

Y aquí hay un código de prueba:

        List<MacAddress> addresses = MacAddress.GetMacAddresses();
        foreach (MacAddress address in addresses)
        {
            Console.WriteLine(address);
        }

Estoy seguro de que el método ToString podría ser mejor, pero cumple su función.

Answer 2

Desde .Net 2.0 ha habido una clase NetworkInterface en el espacio de nombres System.Net.NetworkInformation que le proporcionará esta información. Prueba esto:

        foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
        {
            if (nic.OperationalStatus == OperationalStatus.Up)
            {
                Console.WriteLine(nic.GetPhysicalAddress().ToString());
                break;
            }
        }

Answer 3

Necesita DllImport GetAdaptersInfo - aquí hay un código C #

http://www.codeguru.com/cpp/in/network/networkinformation/comments.php/c5451/?thread=60212

Answer 4

Para cualquiera que use el Compact Framework más limitado (.NET v2.0 CF), el siguiente código funciona tanto en Windows CE 5.0 como en CE 6.0 (leyendo solo el nombre del adaptador, pero busque "typedef struct _IP_ADAPTER_INFO" en MSDN para obtener la definición completa de la estructura devuelta):

private const int MAX_ADAPTER_NAME_LENGTH = 256;
[DllImport ("iphlpapi.dll", SetLastError = true)]
private static extern int GetAdaptersInfo(byte[] abyAdaptor, ref int nSize);

// ...
private static string m_szAdaptorName = "DM9CE1";

// ...
private void GetNetworkAdaptorName()
{
    // The initial call is to determine the size of the memory required. This will fail
    // with the error code "111" which is defined by MSDN to be "ERROR_BUFFER_OVERFLOW".
    // The structure size should be 640 bytes per adaptor.
    int nSize = 0;
    int nReturn = GetAdaptersInfo(null, ref nSize);

    // Allocate memory and get data
    byte[] abyAdapatorInfo = new byte[nSize];
    nReturn = GetAdaptersInfo(abyAdapatorInfo, ref nSize);
    if (nReturn == 0)
    {
        // Find the start and end bytes of the name in the returned structure
        int nStartNamePos = 8;
        int nEndNamePos = 8;
        while ((abyAdapatorInfo[nEndNamePos] != 0) &&
                    ((nEndNamePos - nStartNamePos) < MAX_ADAPTER_NAME_LENGTH))
        {
            // Another character in the name
            nEndNamePos++;
        }

        // Convert the name from a byte array into a string
        m_szAdaptorName = Encoding.UTF8.GetString(
            abyAdapatorInfo, nStartNamePos, (nEndNamePos - nStartNamePos));
    }
    else
    {
        // Failed? Use a hard-coded network adaptor name.
        m_szAdaptorName = "DM9CE1";
    }
}

Answer 5

Parece que esta es una publicación anterior, pero sé que se encontrará con este hilo en busca de ayuda, así que aquí está lo que hice hoy para obtener las direcciones MAC de todas las interfaces de red en mi computadora portátil.

En primer lugar, debe importar lo siguiente

Imports System.Net.NetworkInformation

Esta es la función que devuelve todas las direcciones MAC en una matriz de cadenas

Private Function GetMAC() As String()
    Dim MACAddresses(0) As String
    Dim i As Integer = 0
    Dim NIC As NetworkInterface

    For Each NIC In NetworkInterface.GetAllNetworkInterfaces
        ReDim Preserve MACAddresses(i)
        MACAddresses(i) = String.Format("{0}", NIC.GetPhysicalAddress())
        i += 1
    Next
    Return MACAddresses
End Function

Answer 6

de http://www.dotnetjunkies.com/WebLog/jkirwan/archive/2004/02/10/6943.aspx

  Dim mc As System.Management.ManagementClass
  Dim mo As ManagementObject
  mc = New ManagementClass("Win32_NetworkAdapterConfiguration")
  Dim moc As ManagementObjectCollection = mc.GetInstances()
  For Each mo In moc
     If mo.Item("IPEnabled") = True Then
        ListBox1.Items.Add("MAC address " & mo.Item("MacAddress").ToString())
     End If
  Next

Estoy seguro de que no tendrás problemas para portar este código a C # si necesitas

Answer 7

using Linq..

using System.Net.NetworkInformation;
..

NetworkInterface nic =
    NetworkInterface.GetAllNetworkInterfaces()
    .Where(n => n.OperationalStatus == OperationalStatus.Up).FirstOrDefault();

if (nic != null)
    return nic.GetPhysicalAddress().ToString();