Ottieni l'indirizzo IP locale

In Internet ci sono diversi posti che mostrano come ottenere un indirizzo IP. E molti di loro assomigliano a questo esempio:

String strHostName = string.Empty;
// Getting Ip address of local machine...
// First get the host name of local machine.
strHostName = Dns.GetHostName();
Console.WriteLine("Local Machine's Host Name: " + strHostName);
// Then using host name, get the IP address list..
IPHostEntry ipEntry = Dns.GetHostEntry(strHostName);
IPAddress[] addr = ipEntry.AddressList;

for (int i = 0; i < addr.Length; i++)
{
    Console.WriteLine("IP Address {0}: {1} ", i, addr[i].ToString());
}
Console.ReadLine();

Con questo esempio ottengo diversi indirizzi IP, ma sono interessato solo a ottenere quello che il router assegna al computer che esegue il programma: l'IP che darei a qualcuno se desidera accedere a una cartella condivisa nel mio computer per esempio.

Se non sono connesso a una rete e sono connesso a Internet direttamente tramite un modem senza router, vorrei ricevere un errore. Come posso vedere se il mio computer è collegato a una rete con C # e se è quindi per ottenere l'indirizzo IP LAN.

Per ottenere l'indirizzo IP locale:

public static string GetLocalIPAddress()
{
    var host = Dns.GetHostEntry(Dns.GetHostName());
    foreach (var ip in host.AddressList)
    {
        if (ip.AddressFamily == AddressFamily.InterNetwork)
        {
            return ip.ToString();
        }
    }
    throw new Exception("No network adapters with an IPv4 address in the system!");
}

Per verificare se sei connesso o meno:

System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable();

Esiste un modo più accurato quando sono disponibili indirizzi IP multipli sul computer locale. Connectun socket UDP e leggere il suo endpoint locale:

string localIP;
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0))
{
    socket.Connect("8.8.8.8", 65530);
    IPEndPoint endPoint = socket.LocalEndPoint as IPEndPoint;
    localIP = endPoint.Address.ToString();
}

Connectsu un socket UDP ha il seguente effetto: imposta la destinazione per Send/ Recv, scarta tutti i pacchetti da altri indirizzi e - che è quello che usiamo - trasferisce il socket nello stato "connesso", imposta i campi appropriati. Ciò include la verifica dell'esistenza del percorso verso la destinazione in base alla tabella di routing del sistema e l'impostazione dell'endpoint locale di conseguenza. L'ultima parte sembra non essere documentata ufficialmente ma sembra un tratto integrale dell'API socket Berkeley (un effetto collaterale dello stato "connesso" UDP) che funziona in modo affidabile sia su Windows che su Linux attraverso versioni e distribuzioni.

Quindi, questo metodo fornirà l'indirizzo locale che verrebbe utilizzato per connettersi all'host remoto specificato. Non è stata stabilita alcuna connessione reale, quindi l'ip remoto specificato può essere irraggiungibile.

Rifattorizzare il codice di Mrcheif per sfruttare Linq (es. .Net 3.0+). .

private IPAddress LocalIPAddress()
{
    if (!System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
    {
        return null;
    }

    IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName());

    return host
        .AddressList
        .FirstOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork);
}

:)

So che questo potrebbe dare dei calci a un cavallo morto, ma forse questo può aiutare qualcuno. Ho cercato dappertutto un modo per trovare il mio indirizzo IP locale, ma ovunque trovo che dice di usare:

Dns.GetHostEntry(Dns.GetHostName());

Non mi piace affatto perché ottiene tutti gli indirizzi assegnati al tuo computer. Se si dispone di più interfacce di rete (che praticamente tutti i computer fanno ora al giorno) non si ha idea di quale indirizzo corrisponda a quale interfaccia di rete. Dopo aver fatto un sacco di ricerche, ho creato una funzione per utilizzare la classe NetworkInterface e strapparne le informazioni. In questo modo posso dire che tipo di interfaccia è (Ethernet, wireless, loopback, tunnel, ecc.), Se è attiva o meno e SOOO molto di più.

public string GetLocalIPv4(NetworkInterfaceType _type)
{
    string output = "";
    foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
    {
        if (item.NetworkInterfaceType == _type && item.OperationalStatus == OperationalStatus.Up)
        {
            foreach (UnicastIPAddressInformation ip in item.GetIPProperties().UnicastAddresses)
            {
                if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
                {
                    output = ip.Address.ToString();
                }
            }
        }
    }
    return output;
}

Ora per ottenere l'indirizzo IPv4 della chiamata dell'interfaccia di rete Ethernet:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

O la tua interfaccia wireless:

GetLocalIPv4(NetworkInterfaceType.Wireless80211);

Se si tenta di ottenere un indirizzo IPv4 per un'interfaccia wireless, ma sul computer non è installata una scheda wireless, verrà restituita una stringa vuota. Stessa cosa con l'interfaccia Ethernet.

Spero che questo aiuti qualcuno! :-)

MODIFICARE:

È stato sottolineato (grazie a @NasBanov) che anche se questa funzione consente di estrarre l'indirizzo IP in un modo molto migliore rispetto all'utilizzo Dns.GetHostEntry(Dns.GetHostName())non funziona molto bene nel supportare più interfacce dello stesso tipo o più indirizzi IP su una singola interfaccia . Restituirà un solo indirizzo IP quando potrebbero essere assegnati più indirizzi. Per restituire TUTTI questi indirizzi assegnati, è possibile semplicemente manipolare la funzione originale per restituire sempre un array anziché una singola stringa. Per esempio:

public static string[] GetAllLocalIPv4(NetworkInterfaceType _type)
{
    List<string> ipAddrList = new List<string>();
    foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
    {
        if (item.NetworkInterfaceType == _type && item.OperationalStatus == OperationalStatus.Up)
        {
            foreach (UnicastIPAddressInformation ip in item.GetIPProperties().UnicastAddresses)
            {
                if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
                {
                    ipAddrList.Add(ip.Address.ToString());
                }
            }
        }
    }
    return ipAddrList.ToArray();
}

Ora questa funzione restituirà TUTTI gli indirizzi assegnati per uno specifico tipo di interfaccia. Ora per ottenere una sola stringa, è possibile utilizzare l' .FirstOrDefault()estensione per restituire il primo elemento dell'array o, se è vuoto, restituire una stringa vuota.

GetLocalIPv4(NetworkInterfaceType.Ethernet).FirstOrDefault();

Ecco una versione modificata (da quella di compman2408) che ha funzionato per me:

    internal static string GetLocalIPv4(NetworkInterfaceType _type)
    {  // Checks your IP adress from the local network connected to a gateway. This to avoid issues with double network cards
        string output = "";  // default output
        foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces()) // Iterate over each network interface
        {  // Find the network interface which has been provided in the arguments, break the loop if found
            if (item.NetworkInterfaceType == _type && item.OperationalStatus == OperationalStatus.Up)
            {   // Fetch the properties of this adapter
                IPInterfaceProperties adapterProperties = item.GetIPProperties();
                // Check if the gateway adress exist, if not its most likley a virtual network or smth
                if (adapterProperties.GatewayAddresses.FirstOrDefault() != null)
                {   // Iterate over each available unicast adresses
                    foreach (UnicastIPAddressInformation ip in adapterProperties.UnicastAddresses)
                    {   // If the IP is a local IPv4 adress
                        if (ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                        {   // we got a match!
                            output = ip.Address.ToString();
                            break;  // break the loop!!
                        }
                    }
                }
            }
            // Check if we got a result if so break this method
            if (output != "") { break; }
        }
        // Return results
        return output;
    }

Puoi chiamare questo metodo per esempio come:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

La modifica: sto recuperando l'IP da un adattatore a cui è assegnato un IP gateway. Seconda modifica: ho aggiunto docstring e break statement per rendere questo metodo più efficiente.

Questo è il miglior codice che ho trovato per ottenere l'IP corrente, evitando di ottenere host VMWare o altri indirizzi IP non validi.

public string GetLocalIpAddress()
{
    UnicastIPAddressInformation mostSuitableIp = null;

    var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

    foreach (var network in networkInterfaces)
    {
        if (network.OperationalStatus != OperationalStatus.Up)
            continue;

        var properties = network.GetIPProperties();

        if (properties.GatewayAddresses.Count == 0)
            continue;

        foreach (var address in properties.UnicastAddresses)
        {
            if (address.Address.AddressFamily != AddressFamily.InterNetwork)
                continue;

            if (IPAddress.IsLoopback(address.Address))
                continue;

            if (!address.IsDnsEligible)
            {
                if (mostSuitableIp == null)
                    mostSuitableIp = address;
                continue;
            }

            // The best IP is the IP got from DHCP server
            if (address.PrefixOrigin != PrefixOrigin.Dhcp)
            {
                if (mostSuitableIp == null || !mostSuitableIp.IsDnsEligible)
                    mostSuitableIp = address;
                continue;
            }

            return address.Address.ToString();
        }
    }

    return mostSuitableIp != null 
        ? mostSuitableIp.Address.ToString()
        : "";
}

Penso che usare LinQ sia più semplice:

Dns.GetHostEntry(Dns.GetHostName())
   .AddressList
   .First(x => x.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
   .ToString()

Per una risata, ho pensato di provare a ottenere una singola istruzione LINQ utilizzando il nuovo operatore null # C # 6. Sembra piuttosto pazzo e probabilmente terribilmente inefficiente, ma funziona.

private string GetLocalIPv4(NetworkInterfaceType type = NetworkInterfaceType.Ethernet)
{
    // Bastardized from: http://stackoverflow.com/a/28621250/2685650.

    return NetworkInterface
        .GetAllNetworkInterfaces()
        .FirstOrDefault(ni =>
            ni.NetworkInterfaceType == type
            && ni.OperationalStatus == OperationalStatus.Up
            && ni.GetIPProperties().GatewayAddresses.FirstOrDefault() != null
            && ni.GetIPProperties().UnicastAddresses.FirstOrDefault(ip => ip.Address.AddressFamily == AddressFamily.InterNetwork) != null
        )
        ?.GetIPProperties()
        .UnicastAddresses
        .FirstOrDefault(ip => ip.Address.AddressFamily == AddressFamily.InterNetwork)
        ?.Address
        ?.ToString()
        ?? string.Empty;
}

Logica per gentile concessione di Gerardo H(e per riferimento compman2408).

Altro modo per ottenere IP usando l'espressione linq:

public static List<string> GetAllLocalIPv4(NetworkInterfaceType type)
{
    return NetworkInterface.GetAllNetworkInterfaces()
                   .Where(x => x.NetworkInterfaceType == type && x.OperationalStatus == OperationalStatus.Up)
                   .SelectMany(x => x.GetIPProperties().UnicastAddresses)
                   .Where(x => x.Address.AddressFamily == AddressFamily.InterNetwork)
                   .Select(x => x.Address.ToString())
                   .ToList();
}

@mrcheif Ho trovato questa risposta oggi ed è stato molto utile anche se ha restituito un IP errato (non dovuto al codice non funzionante) ma ha dato un IP internetwork errato quando hai cose come Himachi in esecuzione.

public static string localIPAddress()
{
    IPHostEntry host;
    string localIP = "";
    host = Dns.GetHostEntry(Dns.GetHostName());

    foreach (IPAddress ip in host.AddressList)
    {
        localIP = ip.ToString();

        string[] temp = localIP.Split('.');

        if (ip.AddressFamily == AddressFamily.InterNetwork && temp[0] == "192")
        {
            break;
        }
        else
        {
            localIP = null;
        }
    }

    return localIP;
}

Testato con una o più schede LAN e macchine virtuali

public static string DisplayIPAddresses()
    {
        string returnAddress = String.Empty;

        // Get a list of all network interfaces (usually one per network card, dialup, and VPN connection)
        NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();

        foreach (NetworkInterface network in networkInterfaces)
        {
            // Read the IP configuration for each network
            IPInterfaceProperties properties = network.GetIPProperties();

            if (network.NetworkInterfaceType == NetworkInterfaceType.Ethernet &&
                   network.OperationalStatus == OperationalStatus.Up &&
                   !network.Description.ToLower().Contains("virtual") &&
                   !network.Description.ToLower().Contains("pseudo"))
            {
                // Each network interface may have multiple IP addresses
                foreach (IPAddressInformation address in properties.UnicastAddresses)
                {
                    // We're only interested in IPv4 addresses for now
                    if (address.Address.AddressFamily != AddressFamily.InterNetwork)
                        continue;

                    // Ignore loopback addresses (e.g., 127.0.0.1)
                    if (IPAddress.IsLoopback(address.Address))
                        continue;

                    returnAddress = address.Address.ToString();
                    Console.WriteLine(address.Address.ToString() + " (" + network.Name + " - " + network.Description + ")");
                }
            }
        }

       return returnAddress;
    }

Solo una mia versione aggiornata usando LINQ:

/// <summary>
/// Gets the local Ipv4.
/// </summary>
/// <returns>The local Ipv4.</returns>
/// <param name="networkInterfaceType">Network interface type.</param>
IPAddress GetLocalIPv4(NetworkInterfaceType networkInterfaceType)
{
    var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces().Where(i => i.NetworkInterfaceType == networkInterfaceType && i.OperationalStatus == OperationalStatus.Up);

    foreach (var networkInterface in networkInterfaces)
    {
        var adapterProperties = networkInterface.GetIPProperties();

        if (adapterProperties.GatewayAddresses.FirstOrDefault() == null)
                continue;
        foreach (var ip in networkInterface.GetIPProperties().UnicastAddresses)
        {
            if (ip.Address.AddressFamily != AddressFamily.InterNetwork)
                    continue;

            return ip.Address;
        }
    }

    return null;
}

Prerequisiti: è necessario aggiungere il riferimento System.Data.Linq e consultarlo

using System.Linq;
string ipAddress ="";
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
ipAddress = Convert.ToString(ipHostInfo.AddressList.FirstOrDefault(address => address.AddressFamily == AddressFamily.InterNetwork));

Stavo anche lottando per ottenere l'IP corretto.

Ho provato una varietà di soluzioni qui, ma nessuna mi ha fornito l'effetto desiderato. Quasi tutti i test condizionali forniti non hanno consentito di utilizzare alcun indirizzo.

Questo è ciò che ha funzionato per me, spero che aiuti ...

var firstAddress = (from address in NetworkInterface.GetAllNetworkInterfaces().Select(x => x.GetIPProperties()).SelectMany(x => x.UnicastAddresses).Select(x => x.Address)
                    where !IPAddress.IsLoopback(address) && address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork
                    select address).FirstOrDefault();

Console.WriteLine(firstAddress);

string str="";

System.Net.Dns.GetHostName();

IPHostEntry ipEntry = System.Net.Dns.GetHostEntry(str);

IPAddress[] addr = ipEntry.AddressList;

string IP="Your Ip Address Is :->"+ addr[addr.Length - 1].ToString();

Tieni presente che, in generale, potresti avere più traduzioni NAT in corso e più server DNS, ognuno operante su diversi livelli di traduzione NAT.

Cosa succede se si dispone di NAT di livello carrier e si desidera comunicare con altri clienti dello stesso vettore? Nel caso generale non lo saprai mai perché potresti apparire con nomi host diversi in ogni traduzione NAT.

Obsoleto andato, questo funziona per me

public static IPAddress GetIPAddress()
{ 
 IPAddress ip = Dns.GetHostAddresses(Dns.GetHostName()).Where(address => 
 address.AddressFamily == AddressFamily.InterNetwork).First();
 return ip;
}

Aggiornando la risposta di Mrchief con Linq, avremo:

public static IPAddress GetLocalIPAddress()
{
   var host = Dns.GetHostEntry(Dns.GetHostName());
   var ipAddress= host.AddressList.FirstOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork);
   return ipAddress;
}

Ciò restituisce gli indirizzi da tutte le interfacce che hanno indirizzi gateway e indirizzi unicast in due elenchi separati, IPV4 e IPV6.

public static (List<IPAddress> V4, List<IPAddress> V6) GetLocal()
{
    List<IPAddress> foundV4 = new List<IPAddress>();
    List<IPAddress> foundV6 = new List<IPAddress>();

    NetworkInterface.GetAllNetworkInterfaces().ToList().ForEach(ni =>
    {
        if (ni.GetIPProperties().GatewayAddresses.FirstOrDefault() != null)
        {
            ni.GetIPProperties().UnicastAddresses.ToList().ForEach(ua =>
            {
                if (ua.Address.AddressFamily == AddressFamily.InterNetwork) foundV4.Add(ua.Address);
                if (ua.Address.AddressFamily == AddressFamily.InterNetworkV6) foundV6.Add(ua.Address);
            });
        }
    });

    return (foundV4.Distinct().ToList(), foundV6.Distinct().ToList());
}

Ci sono già molte risposte, ma sto ancora contribuendo alla mia:

public static IPAddress LocalIpAddress() {
    Func<IPAddress, bool> localIpPredicate = ip =>
        ip.AddressFamily == AddressFamily.InterNetwork &&
        ip.ToString().StartsWith("192.168"); //check only for 16-bit block
    return Dns.GetHostEntry(Dns.GetHostName()).AddressList.LastOrDefault(localIpPredicate);
}

Una fodera:

public static IPAddress LocalIpAddress() => Dns.GetHostEntry(Dns.GetHostName()).AddressList.LastOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork && ip.ToString().StartsWith("192.168"));

nota: cerca dall'ultimo perché ha funzionato ancora dopo che alcune interfacce sono state aggiunte al dispositivo, come MobileHotspot, VPN o altri adattatori virtuali fantasiosi.

Inoltre, basta un semplice codice per ottenere l'IP del cliente:

        public static string getclientIP()
        {
            var HostIP = HttpContext.Current != null ? HttpContext.Current.Request.UserHostAddress : "";
            return HostIP;
        }

Spero ti sia d'aiuto.

Dns.GetHostEntry(Dns.GetHostName()).AddressList[1].MapToIPv4() //returns 192.168.14.1

Codice di compman2408 modificato per poter iterare su ciascuno di essi NetworkInterfaceType.

public static string GetLocalIPv4 (NetworkInterfaceType _type) {
    string output = null;
    foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces ()) {
        if (item.NetworkInterfaceType == _type && item.OperationalStatus == OperationalStatus.Up) {
            foreach (UnicastIPAddressInformation ip in item.GetIPProperties ().UnicastAddresses) {
                if (ip.Address.AddressFamily == AddressFamily.InterNetwork) {
                    output = ip.Address.ToString ();
                }
            }
        }
    }
    return output;
}

E puoi chiamarlo così:

static void Main (string[] args) {
    // Get all possible enum values:
    var nitVals = Enum.GetValues (typeof (NetworkInterfaceType)).Cast<NetworkInterfaceType> ();

    foreach (var nitVal in nitVals) {
        Console.WriteLine ($"{nitVal} => {GetLocalIPv4 (nitVal) ?? "NULL"}");
    }
}

Imports System.Net
Imports System.Net.Sockets
Function LocalIP()
    Dim strHostName = Dns.GetHostName
    Dim Host = Dns.GetHostEntry(strHostName)
    For Each ip In Host.AddressList
        If ip.AddressFamily = AddressFamily.InterNetwork Then
            txtIP.Text = ip.ToString
        End If
    Next

    Return True
End Function

Sotto la stessa azione

Funzione LocalIP ()

Dim Host As String = Dns.GetHostEntry (Dns.GetHostName) .AddressList (1) .MapToIPv4.ToString

txtIP.Text = Host

Return True

Fine funzione

Dns.GetHostEntry(Dns.GetHostName()).AddressList[1]

una riga di codice: D

Se si dispone di macchine virtuali o schede di rete aggiuntive, potrebbero essere presenti altri valori nell'elenco indirizzi. Il mio suggerimento è di controllare le voci dell'elenco indirizzi e di stampare ciò che è appropriato. Nel mio caso la voce 3 era l'indirizzo ipv4 della mia macchina

IPHostEntry ipHost = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddr = ipHost.AddressList[3];
string ip = ipAddr.ToString();

Non dimenticare di aggiungere using System.Net;