C # में मशीन का मैक पता प्राप्त करने का विश्वसनीय तरीका

Question

मुझे मशीन का मैक पता प्राप्त करने के लिए एक रास्ता चाहिए, चाहे वह ओएस हो जो C # का उपयोग करके चल रहा हो। एप्लिकेशन को XP / Vista / Win7 32 और 64 बिट के साथ-साथ उन ओएस पर भी काम करना होगा लेकिन एक विदेशी भाषा डिफ़ॉल्ट के साथ। कई सी # कमांड और ओएस क्वेरी ओएस में काम नहीं करते हैं। कोई विचार? मैं "ipconfig / all" के आउटपुट को स्क्रैप कर रहा हूं, लेकिन यह बहुत अविश्वसनीय है क्योंकि आउटपुट फॉर्म हर मशीन पर भिन्न होता है।

धन्यवाद

Comments

जब आप ओएस भर में कहते हैं, तो आप अलग-अलग Microsoft OS के पार हैं?

— जॉन वेल्डन

Answer 1

क्लीनर समाधान

var macAddr = 
    (
        from nic in NetworkInterface.GetAllNetworkInterfaces()
        where nic.OperationalStatus == OperationalStatus.Up
        select nic.GetPhysicalAddress().ToString()
    ).FirstOrDefault();

या:

String firstMacAddress = NetworkInterface
    .GetAllNetworkInterfaces()
    .Where( nic => nic.OperationalStatus == OperationalStatus.Up && nic.NetworkInterfaceType != NetworkInterfaceType.Loopback )
    .Select( nic => nic.GetPhysicalAddress().ToString() )
    .FirstOrDefault();

Comments

या लंबोदर, अगर तुम्हारी बात यही है! return NetworkInterface.GetAllNetworkInterfaces().Where(nic => nic.OperationalStatus == OperationalStatus.Up).Select(nic => nic.GetPhysicalAddress().ToString()).FirstOrDefault();(यदि यह आपकी चीज नहीं है, तो यह आपकी चीज होनी चाहिए।)

— गॉनेले

सबसे तेज़ पाने के लिए संक्षिप्त तरीका: var networks = NetworkInterface.GetAllNetworkInterfaces(); var activeNetworks = networks.Where(ni => ni.OperationalStatus == OperationalStatus.Up && ni.NetworkInterfaceType != NetworkInterfaceType.Loopback); var sortedNetworks = activeNetworks.OrderByDescending(ni => ni.Speed); return sortedNetworks.First().GetPhysicalAddress().ToString();

— ग्राहम नाइट

पहले का चयन करना हमेशा सबसे अच्छा विकल्प नहीं होता है। सबसे अधिक इस्तेमाल किया जाने वाला कनेक्शन: stackoverflow.com/a/51821927/3667

— रामुनास

अनुकूलन नोट: आप FirstOrDefaultअंतिम से पहले कॉल कर सकते हैं Select। इस तरह, इसे केवल भौतिक पता मिलेगा और इसे वास्तविक रूप से प्राप्त करने के लिए अनुक्रमित करें NetworkInterface। के बाद शून्य चेक (?) जोड़ना न भूलें FirstOrDefault।

— ग्रीगामोर्को

इसे प्राप्त करने के लिए एक कम्प्यूटेशनल तेज़ तरीका, आपको उन सभी नेटवर्कों का मूल्यांकन करने की आवश्यकता नहीं है जो दी गई स्थिति से मेल खाते हैं, आपको उनमें से सबसे पहले की आवश्यकता है: NetworkInterface .GetAllNetworkInterfaces() .FirstOrDefault(nic => nic.OperationalStatus == OperationalStatus.Up && nic.NetworkInterfaceType != NetworkInterfaceType.Loopback)? .GetPhysicalAddress().ToString();

— एलेसेंड्रो मुज़ी

Answer 2

यहां कुछ C # कोड दिए गए हैं जो पहले ऑपरेशनल नेटवर्क इंटरफेस का मैक एड्रेस लौटाते हैं। मान लें NetworkInterfaceविधानसभा क्रम में कार्यान्वित किया जाता (यानी मोनो) अन्य ऑपरेटिंग सिस्टम पर इस्तेमाल किया तो यह अन्य ऑपरेटिंग सिस्टम पर काम करेगा।

नया संस्करण: सबसे तेज़ गति वाला एनआईसी लौटाता है जिसमें एक वैध मैक पता भी होता है।

/// <summary>
/// Finds the MAC address of the NIC with maximum speed.
/// </summary>
/// <returns>The MAC address.</returns>
private string GetMacAddress()
{
    const int MIN_MAC_ADDR_LENGTH = 12;
    string macAddress = string.Empty;
    long maxSpeed = -1;

    foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
    {
        log.Debug(
            "Found MAC Address: " + nic.GetPhysicalAddress() +
            " Type: " + nic.NetworkInterfaceType);

        string tempMac = nic.GetPhysicalAddress().ToString();
        if (nic.Speed > maxSpeed &&
            !string.IsNullOrEmpty(tempMac) &&
            tempMac.Length >= MIN_MAC_ADDR_LENGTH)
        {
            log.Debug("New Max Speed = " + nic.Speed + ", MAC: " + tempMac);
            maxSpeed = nic.Speed;
            macAddress = tempMac;
        }
    }

    return macAddress;
}

मूल संस्करण: सिर्फ पहला रिटर्न।

/// <summary>
/// Finds the MAC address of the first operation NIC found.
/// </summary>
/// <returns>The MAC address.</returns>
private string GetMacAddress()
{
    string macAddresses = string.Empty;

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

    return macAddresses;
}

केवल एक चीज जो मुझे इस दृष्टिकोण के बारे में पसंद नहीं है यदि आपके पास नॉर्टेल पैकेट मिनिपोर्ट या किसी प्रकार का वीपीएन कनेक्शन है तो इसे चुने जाने की संभावना है। जहां तक ​​मैं बता सकता हूं, वास्तविक भौतिक डिवाइस के मैक को कुछ प्रकार के वर्चुअल नेटवर्क इंटरफ़ेस से अलग करने का कोई तरीका नहीं है।

Comments

सिर्फ पहला ऑपरेशनल इंटरफेस न चुनें। यह लूपबैक इंटरफेस लौटा सकता है, कभी-कभार 3 जी कार्ड और इतने पर, जो शायद आप नहीं चाहते हैं। NetworkInterfaceType ( msdn.microsoft.com/en-us/library/… ) आपको NetworkInterface कनेक्शन के बारे में अधिक जानकारी देगा ताकि आप अधिक सूचित विकल्प बना सकें। यह भी ध्यान रखें कि एक मशीन पर कई सक्रिय कनेक्शन हो सकते हैं और उनका क्रम अनुमानित नहीं हो सकता है।

— डेव आर।

@DaveR। मैंने NetworkInterfaceType को देखा, यह मूल रूप से लगभग हमेशा ईथरनेट लौटाता है, जबकि यह मेरे अनुभव में एक आभासी एडाप्टर था, इसलिए मुझे यह बहुत बेकार लगा।

— ’११ तक

आपको सबसे कम गेटवेमेट्रिक वाले इंटरफ़ेस को चुनना चाहिए। यह वह कनेक्शन होना चाहिए जिसमें "सबसे तेज़, सबसे विश्वसनीय, या कम से कम संसाधन-गहन मार्ग" हो। मूल रूप से यह आपको इंटरफ़ेस का उपयोग करना पसंद करेगा। हालाँकि, मुझे लगता है कि आपको वास्तव में प्राप्त करने के लिए WMI की आवश्यकता है। मैं देखूंगा कि क्या मुझे वह काम मिल सकता है ...

— AVee

पूर्णता के लिए, नेटवर्कइंटरफेस क्लास को using System.Net.NetworkInformation;

— iancoleman

FWIW, अगर आपके पास एक गीगाबिट एनआईसी और हाइपर-वी स्थापित है, तो आपके पास 10gigabit वर्चुअल एनआईसी भी होगा। :) हल करने के लिए कठिन समस्या ...

— क्रिस्टोफर पेंटर

Answer 3

Win32_NetworkAdapterConfiguration WMI वर्ग की MACAddress संपत्ति आपको एक एडेप्टर मैक पते के साथ प्रदान कर सकती है। (सिस्टम। प्रबंधन नाम स्थान)

MACAddress

    Data type: string
    Access type: Read-only

    Media Access Control (MAC) address of the network adapter. A MAC address is assigned by the manufacturer to uniquely identify the network adapter.

    Example: "00:80:C7:8F:6C:96"

यदि आप WMI API (Windows मैनेजमेंट इंस्ट्रूमेंटेशन) से परिचित नहीं हैं, तो .NET ऐप्स के लिए यहाँ एक अच्छा अवलोकन है ।

WMI .net रनटाइम के साथ विंडोज़ के सभी संस्करण में उपलब्ध है।

यहाँ एक कोड उदाहरण है:

System.Management.ManagementClass mc = default(System.Management.ManagementClass);
ManagementObject mo = default(ManagementObject);
mc = new ManagementClass("Win32_NetworkAdapterConfiguration");

ManagementObjectCollection moc = mc.GetInstances();
    foreach (var mo in moc) {
        if (mo.Item("IPEnabled") == true) {
              Adapter.Items.Add("MAC " + mo.Item("MacAddress").ToString());
         }
     }

Answer 4

WMI सबसे अच्छा समाधान है यदि आप जिस मशीन से कनेक्ट कर रहे हैं वह एक विंडोज़ मशीन है, लेकिन यदि आप एक लिनक्स, मैक, या अन्य प्रकार के नेटवर्क एडाप्टर को देख रहे हैं, तो आपको कुछ और उपयोग करने की आवश्यकता होगी। यहाँ कुछ विकल्प दिए गए हैं:

1. DOS कमांड nbtstat -a का उपयोग करें। एक प्रक्रिया बनाएं, इस कमांड को कॉल करें, आउटपुट को पार्स करें।
2. यह सुनिश्चित करने के लिए कि आपका ARIC तालिका ARP तालिका में है, तो DOS कमांड arp -a का उपयोग करें। विकल्प 1 की तरह प्रक्रिया के आउटपुट को पार्स करें।
3. Iphlpapi.dll में sendarp के लिए एक खतरनाक अप्रबंधित कॉल का उपयोग करें

वस्तु # 3 का एक नमूना। यदि WMI एक व्यवहार्य समाधान नहीं है तो यह सबसे अच्छा विकल्प लगता है:

using System.Runtime.InteropServices;
...
[DllImport("iphlpapi.dll", ExactSpelling = true)]
        public static extern int SendARP(int DestIP, int SrcIP, byte[] pMacAddr, ref uint PhyAddrLen);
...
private string GetMacUsingARP(string IPAddr)
{
    IPAddress IP = IPAddress.Parse(IPAddr);
    byte[] macAddr = new byte[6];
    uint macAddrLen = (uint)macAddr.Length;

    if (SendARP((int)IP.Address, 0, macAddr, ref macAddrLen) != 0)
        throw new Exception("ARP command failed");

    string[] str = new string[(int)macAddrLen];
    for (int i = 0; i < macAddrLen; i++)
        str[i] = macAddr[i].ToString("x2");

    return string.Join(":", str);
}

जहां यह देय है, उसे क्रेडिट देने के लिए, यह उस कोड का आधार है: http://www.pinvoke.net/default.aspx/iphlpapi.sendarp#

Comments

मैं ओपी के रूप में एक ही चीज़ की तलाश में था और यह वही सटीक चीज़ है जिसकी मुझे ज़रूरत थी!

— क्यू। हैमर

विकल्प 1 और 2 में, यदि आप विंडोज़ मशीन पर हैं और लिनक्स या मैक पर समतुल्य कमांड का उपयोग करते हैं, तो DOS कमांड का अर्थ है?

— रायकोल अमरो

Answer 5

हम सबसे कम मीट्रिक वाले इंटरफ़ेस का मैक पता प्राप्त करने के लिए WMI का उपयोग करते हैं, उदाहरण के लिए इंटरफ़ेस विंडो का उपयोग करना पसंद करेंगे, जैसे:

public static string GetMACAddress()
{
    ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration where IPEnabled=true");
    IEnumerable<ManagementObject> objects = searcher.Get().Cast<ManagementObject>();
    string mac = (from o in objects orderby o["IPConnectionMetric"] select o["MACAddress"].ToString()).FirstOrDefault();
    return mac;
}

या सिल्वरलाइट में (उच्चीकृत ट्रस्ट की आवश्यकता है):

public static string GetMACAddress()
{
    string mac = null;
    if ((Application.Current.IsRunningOutOfBrowser) && (Application.Current.HasElevatedPermissions) && (AutomationFactory.IsAvailable))
    {
        dynamic sWbemLocator = AutomationFactory.CreateObject("WbemScripting.SWBemLocator");
        dynamic sWbemServices = sWbemLocator.ConnectServer(".");
        sWbemServices.Security_.ImpersonationLevel = 3; //impersonate

        string query = "SELECT * FROM Win32_NetworkAdapterConfiguration where IPEnabled=true";
        dynamic results = sWbemServices.ExecQuery(query);

        int mtu = int.MaxValue;
        foreach (dynamic result in results)
        {
            if (result.IPConnectionMetric < mtu)
            {
                mtu = result.IPConnectionMetric;
                mac = result.MACAddress;
            }
        }
    }
    return mac;
}

Answer 6

public static PhysicalAddress GetMacAddress()
{
    var myInterfaceAddress = NetworkInterface.GetAllNetworkInterfaces()
        .Where(n => n.OperationalStatus == OperationalStatus.Up && n.NetworkInterfaceType != NetworkInterfaceType.Loopback)
        .OrderByDescending(n => n.NetworkInterfaceType == NetworkInterfaceType.Ethernet)
        .Select(n => n.GetPhysicalAddress())
        .FirstOrDefault();

    return myInterfaceAddress;
}

Comments

अगर मैं इस कोड को चलाता हूं तो क्या इसे एप्लिकेशन चलाने वाले व्यक्ति का पता मिल जाएगा? इसका अर्थ यह है कि सर्वर IP पता नहीं मिलेगा जहां यह होस्ट किया गया है, सही है?

— नैट पेट

यह होस्ट मशीन, सर्वर का मैक पता प्राप्त करता है।

— टोनी

Answer 7

IMHO प्रथम मैक पते पर वापस आना अच्छा विचार नहीं है, खासकर जब वर्चुअल मशीनों की मेजबानी की जाती है। इसलिए मैं बाइट्स भेजने / प्राप्त करने की जांच करता हूं और सबसे अधिक उपयोग किए जाने वाले कनेक्शन का चयन करता हूं, जो कि सही नहीं है, लेकिन 9/10 बार सही होना चाहिए।

public string GetDefaultMacAddress()
{
    Dictionary<string, long> macAddresses = new Dictionary<string, long>();
    foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
    {
        if (nic.OperationalStatus == OperationalStatus.Up)
            macAddresses[nic.GetPhysicalAddress().ToString()] = nic.GetIPStatistics().BytesSent + nic.GetIPStatistics().BytesReceived;
    }
    long maxValue = 0;
    string mac = "";
    foreach(KeyValuePair<string, long> pair in macAddresses)
    {
        if (pair.Value > maxValue)
        {
            mac = pair.Key;
            maxValue = pair.Value;
        }
    }
    return mac;
}

Answer 8

यह विधि निर्दिष्ट यूआरएल और पोर्ट से कनेक्ट करने के लिए उपयोग किए जाने वाले नेटवर्क इंटरफ़ेस के मैक पते को निर्धारित करेगी।

यहाँ सभी उत्तर इस लक्ष्य को प्राप्त करने में सक्षम नहीं हैं।

मैंने यह उत्तर वर्षों पहले (2014 में) लिखा था। इसलिए मैंने इसे थोड़ा "फेस लिफ्ट" देने का फैसला किया। कृपया अपडेट अनुभाग देखें

    /// <summary>
    /// Get the MAC of the Netowrk Interface used to connect to the specified url.
    /// </summary>
    /// <param name="allowedURL">URL to connect to.</param>
    /// <param name="port">The port to use. Default is 80.</param>
    /// <returns></returns>
    private static PhysicalAddress GetCurrentMAC(string allowedURL, int port = 80)
    {
        //create tcp client
        var client = new TcpClient();

        //start connection
        client.Client.Connect(new IPEndPoint(Dns.GetHostAddresses(allowedURL)[0], port));

        //wai while connection is established
        while(!client.Connected)
        {
            Thread.Sleep(500);
        }

        //get the ip address from the connected endpoint
        var ipAddress = ((IPEndPoint)client.Client.LocalEndPoint).Address;

        //if the ip is ipv4 mapped to ipv6 then convert to ipv4
        if(ipAddress.IsIPv4MappedToIPv6)
            ipAddress = ipAddress.MapToIPv4();        

        Debug.WriteLine(ipAddress);

        //disconnect the client and free the socket
        client.Client.Disconnect(false);
        
        //this will dispose the client and close the connection if needed
        client.Close();

        var allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

        //return early if no network interfaces found
        if(!(allNetworkInterfaces?.Length > 0))
            return null;

        foreach(var networkInterface in allNetworkInterfaces)
        {
            //get the unicast address of the network interface
            var unicastAddresses = networkInterface.GetIPProperties().UnicastAddresses;
           
            //skip if no unicast address found
            if(!(unicastAddresses?.Count > 0))
                continue;

            //compare the unicast addresses to see 
            //if any match the ip address used to connect over the network
            for(var i = 0; i < unicastAddresses.Count; i++)
            {
                var unicastAddress = unicastAddresses[i];

                //this is unlikely but if it is null just skip
                if(unicastAddress.Address == null)
                    continue;
                
                var ipAddressToCompare = unicastAddress.Address;

                Debug.WriteLine(ipAddressToCompare);

                //if the ip is ipv4 mapped to ipv6 then convert to ipv4
                if(ipAddressToCompare.IsIPv4MappedToIPv6)
                    ipAddressToCompare = ipAddressToCompare.MapToIPv4();

                Debug.WriteLine(ipAddressToCompare);

                //skip if the ip does not match
                if(!ipAddressToCompare.Equals(ipAddress))
                    continue;

                //return the mac address if the ip matches
                return networkInterface.GetPhysicalAddress();
            }
              
        }

        //not found so return null
        return null;
    }

इसे कॉल करने के लिए आपको इस तरह से जुड़ने के लिए एक URL पास करना होगा:

var mac = GetCurrentMAC("www.google.com");

आप पोर्ट नंबर भी निर्दिष्ट कर सकते हैं। यदि निर्दिष्ट डिफ़ॉल्ट 80 नहीं है।

अद्यतन:

2020

• कोड को समझाने के लिए टिप्पणियाँ जोड़ी गईं।
• नए ऑपरेटिंग सिस्टम के साथ उपयोग करने के लिए सही है जो IPV4 से मैप किए गए IPV6 (विंडोज़ 10 की तरह) का उपयोग करते हैं।
• घोंसला कम करना।
• कोड का उपयोग "var" अपग्रेड किया गया।

Comments

यह बहुत दिलचस्प है, मैं इसे आज़माऊंगा, क्योंकि मेरे मामले में मैं ग्राहक को खोजना चाहूंगा) मेरे सर्वर के साथ संवाद करने के लिए उपयोग किया जाने वाला स्रोत पता (यह जरूरी नहीं कि इंटरनेट पर होगा) और बी) मैक पता क्या है एनआईसी का है जो इस आईपी पते को प्रदान कर रहा है ...

— ब्रायन बी

Answer 9

आप एनआईसी आईडी के लिए जा सकते हैं:

 foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces()) {
     if (nic.OperationalStatus == OperationalStatus.Up){
         if (nic.Id == "yay!")
     }
 }

यह मैक पता नहीं है, लेकिन यह एक अद्वितीय पहचानकर्ता है, यदि आप इसे ढूंढ रहे हैं।

Answer 10

मुझे वास्तव में सबसे कम आईपी कनेक्शन मीट्रिक के साथ एवी का समाधान पसंद है! लेकिन अगर उसी मीट्रिक के साथ दूसरा निक स्थापित किया जाता है, तो MAC तुलना विफल हो सकती है ...

बेहतर है कि आप मैक के साथ इंटरफेस का विवरण संग्रहीत करें। बाद की तुलना में आप इस स्ट्रिंग द्वारा सही निक की पहचान कर सकते हैं। यहाँ एक नमूना कोड है:

   public static string GetMacAndDescription()
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration where IPEnabled=true");
        IEnumerable<ManagementObject> objects = searcher.Get().Cast<ManagementObject>();
        string mac = (from o in objects orderby o["IPConnectionMetric"] select o["MACAddress"].ToString()).FirstOrDefault();
        string description = (from o in objects orderby o["IPConnectionMetric"] select o["Description"].ToString()).FirstOrDefault();
        return mac + ";" + description;
    }

    public static string GetMacByDescription( string description)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration where IPEnabled=true");
        IEnumerable<ManagementObject> objects = searcher.Get().Cast<ManagementObject>();
        string mac = (from o in objects where o["Description"].ToString() == description select o["MACAddress"].ToString()).FirstOrDefault();
        return mac;
    }

Answer 11

मान लीजिए कि मेरे पास 192.168.0.182 के अपने स्थानीय आईपी का उपयोग करके TcpConnection है। फिर अगर मैं उस एनआईसी के मैक पते को जानना चाहूंगा, तो मैं इस प्रकार कहूंगा:GetMacAddressUsedByIp("192.168.0.182")

public static string GetMacAddressUsedByIp(string ipAddress)
    {
        var ips = new List<string>();
        string output;

        try
        {
            // Start the child process.
            Process p = new Process();
            // Redirect the output stream of the child process.
            p.StartInfo.UseShellExecute = false;

            p.StartInfo.RedirectStandardOutput = true;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.CreateNoWindow = true;
            p.StartInfo.FileName = "ipconfig";
            p.StartInfo.Arguments = "/all";
            p.Start();
            // Do not wait for the child process to exit before
            // reading to the end of its redirected stream.
            // p.WaitForExit();
            // Read the output stream first and then wait.
            output = p.StandardOutput.ReadToEnd();
            p.WaitForExit();

        }
        catch
        {
            return null;
        }

        // pattern to get all connections
        var pattern = @"(?xis) 
(?<Header>
     (\r|\n) [^\r]+ :  \r\n\r\n
)
(?<content>
    .+? (?= ( (\r\n\r\n)|($)) )
)";

        List<Match> matches = new List<Match>();

        foreach (Match m in Regex.Matches(output, pattern))
            matches.Add(m);

        var connection = matches.Select(m => new
        {
            containsIp = m.Value.Contains(ipAddress),
            containsPhysicalAddress = Regex.Match(m.Value, @"(?ix)Physical \s Address").Success,
            content = m.Value
        }).Where(x => x.containsIp && x.containsPhysicalAddress)
        .Select(m => Regex.Match(m.content, @"(?ix)  Physical \s address [^:]+ : \s* (?<Mac>[^\s]+)").Groups["Mac"].Value).FirstOrDefault();

        return connection;
    }

Comments

यह कुशल नहीं है ... मैं ऐसा करने की सलाह नहीं दूंगा।

— Ivandro IG Jao

Answer 12

वास्तव में इस पुराने पोस्ट को खोदने से नफरत है, लेकिन मुझे लगता है कि सवाल 8-10 खिड़कियों के लिए एक और जवाब के योग्य है।

Windows.Networking.Connectivity नामस्थान से NetworkInformation का उपयोग करके , आप नेटवर्क एडेप्टर विंडोज़ की Id का उपयोग कर सकते हैं। फिर आप पहले से उल्लेखित GetAllNetworkInterfaces () से इंटरफ़ेस मैक एड्रेस प्राप्त कर सकते हैं।

यह Windows Store Apps में NetworkInterface के रूप में System.Net में काम नहीं करेगा। NetworkInformation GetAllNetworkInterfaces को उजागर नहीं करता है।

string GetMacAddress()
{
    var connectionProfile = NetworkInformation.GetInternetConnectionProfile();
    if (connectionProfile == null) return "";

    var inUseId = connectionProfile.NetworkAdapter.NetworkAdapterId.ToString("B").ToUpperInvariant();
    if(string.IsNullOrWhiteSpace(inUseId)) return "";

    var mac = NetworkInterface.GetAllNetworkInterfaces()
        .Where(n => inUseId == n.Id)
        .Select(n => n.GetPhysicalAddress().GetAddressBytes().Select(b=>b.ToString("X2")))
        .Select(macBytes => string.Join(" ", macBytes))
        .FirstOrDefault();

    return mac;
}

Answer 13

string mac = "";
foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
            {

                if (nic.OperationalStatus == OperationalStatus.Up && (!nic.Description.Contains("Virtual") && !nic.Description.Contains("Pseudo")))
                {
                    if (nic.GetPhysicalAddress().ToString() != "")
                    {
                        mac = nic.GetPhysicalAddress().ToString();
                    }
                }
            }
MessageBox.Show(mac);

Comments

इस जवाब को कोड क्या करता है और यह कैसे हल करता है की एक संक्षिप्त विवरण के साथ सुधार किया जा सकता है।

— ग्रेग द इनक्रेडुलस

Answer 14

अपने कोड blak3r को थोड़ा बदल दिया। यदि आपके पास एक ही गति के साथ दो एडेप्टर हैं। मैक द्वारा क्रमबद्ध करें, ताकि आपको हमेशा समान मूल्य मिले।

public string GetMacAddress()
{
    const int MIN_MAC_ADDR_LENGTH = 12;
    string macAddress = string.Empty;
    Dictionary<string, long> macPlusSpeed = new Dictionary<string, long>();
    try
    {
        foreach(NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
        {
            System.Diagnostics.Debug.WriteLine("Found MAC Address: " + nic.GetPhysicalAddress() + " Type: " + nic.NetworkInterfaceType);

            string tempMac = nic.GetPhysicalAddress().ToString();

            if(!string.IsNullOrEmpty(tempMac) && tempMac.Length >= MIN_MAC_ADDR_LENGTH)
                macPlusSpeed.Add(tempMac, nic.Speed);
        }

        macAddress = macPlusSpeed.OrderByDescending(row => row.Value).ThenBy(row => row.Key).FirstOrDefault().Key;
    }
    catch{}

    System.Diagnostics.Debug.WriteLine("Fastest MAC address: " + macAddress);

    return macAddress;
}

Answer 15

foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
{
     if (nic.OperationalStatus == OperationalStatus.Up)
     {
            PhysicalAddress Mac = nic.GetPhysicalAddress();
     }
}

Answer 16

ipconfig.exeसहित कई DLL का उपयोग करके लागू किया जाता है iphlpapi.dll... iphlpapiMSDN में प्रलेखित एक संगत Win32 API का पता चलता है।

Answer 17

इसे इस्तेमाल करे:

    /// <summary>
    /// returns the first MAC address from where is executed 
    /// </summary>
    /// <param name="flagUpOnly">if sets returns only the nic on Up status</param>
    /// <returns></returns>
    public static string[] getOperationalMacAddresses(Boolean flagUpOnly)
    {
        string[] macAddresses = new string[NetworkInterface.GetAllNetworkInterfaces().Count()];

        int i = 0;
        foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces())
        {
            if (nic.OperationalStatus == OperationalStatus.Up || !flagUpOnly)
            {
                macAddresses[i] += ByteToHex(nic.GetPhysicalAddress().GetAddressBytes());
                //break;
                i++;
            }
        }
        return macAddresses;
    }