Obtener dirección IP local

En Internet hay varios lugares que le muestran cómo obtener una dirección IP. Y muchos de ellos se parecen a este ejemplo:

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 este ejemplo, obtengo varias direcciones IP, pero solo estoy interesado en obtener la que el enrutador asigna a la computadora que ejecuta el programa: la IP que le daría a alguien si desea acceder a una carpeta compartida en mi computadora para ejemplo.

Si no estoy conectado a una red y estoy conectado a Internet directamente a través de un módem sin enrutador, me gustaría recibir un error. ¿Cómo puedo ver si mi computadora está conectada a una red con C # y si es para obtener la dirección IP de LAN?

Para obtener la dirección IP local:

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!");
}

Para verificar si estás conectado o no:

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

Hay una forma más precisa cuando hay direcciones IP múltiples disponibles en la máquina local. Connectun socket UDP y lee su punto final local:

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();
}

Connecten un socket UDP tiene el siguiente efecto: establece el destino para Send/ Recv, descarta todos los paquetes de otras direcciones y, que es lo que usamos, transfiere el socket al estado "conectado", configura sus campos apropiados. Esto incluye verificar la existencia de la ruta hacia el destino de acuerdo con la tabla de enrutamiento del sistema y establecer el punto final local en consecuencia. La última parte parece no estar documentada oficialmente, pero parece un rasgo integral de la API de sockets de Berkeley (un efecto secundario del estado UDP "conectado") que funciona de manera confiable tanto en Windows como en Linux en todas las versiones y distribuciones.

Por lo tanto, este método proporcionará la dirección local que se usaría para conectarse al host remoto especificado. No hay una conexión real establecida, por lo tanto, la IP remota especificada puede ser inalcanzable.

Refactorizando el código de Mrcheif para aprovechar Linq (es decir .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);
}

:)

Sé que esto puede estar pateando un caballo muerto, pero tal vez esto pueda ayudar a alguien. He buscado por todas partes una forma de encontrar mi dirección IP local, pero en todas partes me dice que use:

Dns.GetHostEntry(Dns.GetHostName());

No me gusta para nada porque solo obtiene todas las direcciones asignadas a su computadora. Si tiene varias interfaces de red (que prácticamente todas las computadoras tienen hoy en día) no tiene idea de qué dirección va con qué interfaz de red. Después de hacer un montón de investigación, creé una función para usar la clase NetworkInterface y extraer la información de ella. De esta manera puedo decir qué tipo de interfaz es (Ethernet, inalámbrica, loopback, túnel, etc.), si está activa o no, y SOOO mucho más.

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;
}

Ahora para obtener la dirección IPv4 de su interfaz de red Ethernet, llame:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

O tu interfaz inalámbrica:

GetLocalIPv4(NetworkInterfaceType.Wireless80211);

Si intenta obtener una dirección IPv4 para una interfaz inalámbrica, pero su computadora no tiene una tarjeta inalámbrica instalada, solo devolverá una cadena vacía. Lo mismo con la interfaz Ethernet.

¡Espero que esto ayude a alguien! :-)

EDITAR:

Se señaló (gracias @NasBanov) que, aunque esta función consiste en extraer la dirección IP de una manera mucho mejor que usarla, Dns.GetHostEntry(Dns.GetHostName())no funciona muy bien al admitir múltiples interfaces del mismo tipo o múltiples direcciones IP en una sola interfaz . Solo devolverá una única dirección IP cuando pueda haber varias direcciones asignadas. Para devolver TODAS estas direcciones asignadas, simplemente puede manipular la función original para que siempre devuelva una matriz en lugar de una sola cadena. Por ejemplo:

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();
}

Ahora esta función devolverá TODAS las direcciones asignadas para un tipo de interfaz específico. Ahora, para obtener solo una cadena, puede usar la .FirstOrDefault()extensión para devolver el primer elemento de la matriz o, si está vacío, devolver una cadena vacía.

GetLocalIPv4(NetworkInterfaceType.Ethernet).FirstOrDefault();

Aquí hay una versión modificada (de la de compman2408) que funcionó para mí:

    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;
    }

Puede llamar a este método, por ejemplo, como:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

El cambio: estoy recuperando la IP de un adaptador que tiene asignada una IP de puerta de enlace. Segundo cambio: agregué docstrings y break para hacer que este método sea más eficiente.

Este es el mejor código que encontré para obtener la IP actual, evitando obtener el host VMWare u otra dirección IP no válida.

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()
        : "";
}

Creo que usar LinQ es más fácil:

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

Para reír, pensé que trataría de obtener una sola instrucción LINQ utilizando el nuevo operador condicional nulo C # 6. Parece bastante loco y probablemente terriblemente ineficiente, pero funciona.

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;
}

Lógica cortesía de Gerardo H(y por referencia compman2408).

Otra forma de obtener IP usando la expresión 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 Encontré esta respuesta hoy y fue muy útil, aunque devolvió una IP incorrecta (no debido a que el código no funcionara), pero dio una IP entre redes incorrecta cuando tienes cosas como Himachi ejecutándose.

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;
}

Probado con una o varias tarjetas LAN y máquinas virtuales

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 versión actualizada mía 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;
}

Requisitos previos: debe agregar la referencia System.Data.Linq y referirla

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

También estaba luchando para obtener la IP correcta.

Probé una variedad de soluciones aquí, pero ninguna me proporcionó el efecto deseado. Casi todas las pruebas condicionales que se proporcionaron no provocaron el uso de ninguna dirección.

Esto es lo que funcionó para mí, espero que ayude ...

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();

Tenga en cuenta que, en el caso general, podría tener varias traducciones NAT y varios servidores dns, cada uno operando en diferentes niveles de traducción NAT.

¿Qué sucede si tiene NAT de nivel de operador y desea comunicarse con otros clientes del mismo operador? En el caso general, nunca se sabe con certeza porque puede aparecer con diferentes nombres de host en cada traducción NAT.

Obsoleto desaparecido, esto me funciona

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

Actualizando la respuesta de Mrchief con Linq, tendremos:

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

Esto devuelve direcciones de cualquier interfaz que tenga direcciones de puerta de enlace y direcciones de unidifusión en dos listas separadas, 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());
}

Ya hay muchas respuestas, pero sigo aportando la mía:

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);
}

Un trazador de líneas:

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

nota: Busque desde el final porque aún funciona después de que algunas interfaces se hayan agregado al dispositivo, como MobileHotspot, VPN u otros adaptadores virtuales sofisticados.

Además, solo un código simple para obtener Client Ip:

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

Espero que sea de ayuda.

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

Se modificó el código de compman2408 para poder iterar a través de cada uno 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;
}

Y puedes llamarlo así:

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

Debajo de la misma acción

Función LocalIP ()

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

txtIP.Text = Host

Volver verdadero

Función final

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

una línea de código: D

Si tiene máquinas virtuales o tarjetas de red adicionales, puede haber otros valores en la lista de direcciones. Mi sugerencia es verificar las entradas de la lista de direcciones e imprimir lo que sea apropiado. En mi caso, la entrada 3 era la dirección ipv4 de mi máquina

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

No olvides agregar using System.Net;