Obtenir l'adresse IP locale

Sur Internet, il existe plusieurs endroits qui vous montrent comment obtenir une adresse IP. Et beaucoup d'entre eux ressemblent à cet exemple:

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

Avec cet exemple, j'obtiens plusieurs adresses IP, mais je ne souhaite obtenir que celle que le routeur attribue à l'ordinateur exécutant le programme: l'adresse IP que je donnerais à quelqu'un s'il souhaite accéder à un dossier partagé sur mon ordinateur pour exemple.

Si je ne suis pas connecté à un réseau et que je suis connecté à Internet directement via un modem sans routeur, je voudrais obtenir une erreur. Comment puis-je voir si mon ordinateur est connecté à un réseau avec C # et si c'est pour obtenir l'adresse IP LAN.

Pour obtenir l'adresse 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!");
}

Pour vérifier si vous êtes connecté ou non:

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

Il existe un moyen plus précis lorsqu'il existe plusieurs adresses IP disponibles sur la machine locale. Connectun socket UDP et lire son point de terminaison 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();
}

Connect sur un socket UDP a l'effet suivant: il définit la destination de Send / Recv, rejette tous les paquets provenant d'autres adresses, et - ce que nous utilisons - transfère le socket dans l'état "connecté", définit ses champs appropriés. Cela comprend la vérification de l'existence de l'itinéraire vers la destination en fonction de la table de routage du système et la définition du point de terminaison local en conséquence. La dernière partie ne semble pas être officiellement documentée, mais elle ressemble à un trait intégral de l'API des sockets Berkeley (un effet secondaire de l'état "connecté" UDP) qui fonctionne de manière fiable dans Windows et Linux à travers les versions et les distributions.

Ainsi, cette méthode donnera l'adresse locale qui serait utilisée pour se connecter à l'hôte distant spécifié. Il n'y a pas de connexion réelle établie, l'IP distante spécifiée peut donc être inaccessible.

Refactorisation du code de Mrcheif pour exploiter Linq (c'est-à-dire .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);
}

:)

Je sais que cela peut donner un coup de pied à un cheval mort, mais cela peut peut-être aider quelqu'un. J'ai cherché partout un moyen de trouver mon adresse IP locale, mais partout où je trouve, il est dit d'utiliser:

Dns.GetHostEntry(Dns.GetHostName());

Je n'aime pas ça du tout parce qu'il obtient juste toutes les adresses attribuées à votre ordinateur. Si vous avez plusieurs interfaces réseau (ce que presque tous les ordinateurs font de nos jours), vous ne savez pas quelle adresse va avec quelle interface réseau. Après avoir fait un tas de recherches, j'ai créé une fonction pour utiliser la classe NetworkInterface et en extraire les informations. De cette façon, je peux dire de quel type d'interface il s'agit (Ethernet, sans fil, bouclage, tunnel, etc.), qu'elle soit active ou non, et SOOO beaucoup plus.

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

Maintenant, pour obtenir l'adresse IPv4 de votre appel d'interface réseau Ethernet:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

Ou votre interface sans fil:

GetLocalIPv4(NetworkInterfaceType.Wireless80211);

Si vous essayez d'obtenir une adresse IPv4 pour une interface sans fil, mais que votre ordinateur n'a pas de carte sans fil installée, il renverra simplement une chaîne vide. Même chose avec l'interface Ethernet.

J'espère que cela aide quelqu'un! :-)

ÉDITER:

Il a été souligné (merci @NasBanov) que même si cette fonction permet d'extraire l'adresse IP d'une bien meilleure manière que de l'utiliser, Dns.GetHostEntry(Dns.GetHostName())elle ne réussit pas très bien à prendre en charge plusieurs interfaces du même type ou plusieurs adresses IP sur une seule interface. . Il ne renverra une seule adresse IP que si plusieurs adresses peuvent être attribuées. Pour renvoyer TOUTES ces adresses attribuées, vous pouvez simplement manipuler la fonction d'origine pour toujours renvoyer un tableau au lieu d'une seule chaîne. Par exemple:

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

Maintenant, cette fonction retournera TOUTES les adresses attribuées pour un type d'interface spécifique. Maintenant, pour obtenir une seule chaîne, vous pouvez utiliser l' .FirstOrDefault()extension pour renvoyer le premier élément du tableau ou, s'il est vide, renvoyer une chaîne vide.

GetLocalIPv4(NetworkInterfaceType.Ethernet).FirstOrDefault();

Voici une version modifiée (de celle de compman2408) qui a fonctionné pour moi:

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

Vous pouvez appeler cette méthode par exemple comme:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

Le changement: je récupère l'IP à partir d'un adaptateur auquel une passerelle IP a été affectée. Deuxième changement: j'ai ajouté des docstrings et une instruction break pour rendre cette méthode plus efficace.

C'est le meilleur code que j'ai trouvé pour obtenir l'adresse IP actuelle, en évitant d'obtenir l'hôte VMWare ou une autre adresse IP non valide.

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

Je pense que l'utilisation de LinQ est plus facile:

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

Pour rire, j'ai pensé essayer d'obtenir une seule instruction LINQ en utilisant le nouvel opérateur C # 6 à condition nulle. Semble assez fou et probablement horriblement inefficace, mais cela fonctionne.

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

Logique gracieuseté de Gerardo H(et par référence compman2408).

Autre moyen d'obtenir IP en utilisant l'expression 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 J'ai trouvé cette réponse aujourd'hui et elle a été très utile même si elle a renvoyé une mauvaise adresse IP (pas à cause du code qui ne fonctionne pas) mais elle a donné la mauvaise adresse IP interréseau lorsque vous avez des choses comme Himachi en cours d'exécution.

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

Testé avec une ou plusieurs cartes LAN et machines virtuelles

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

Juste une version mise à jour de la mienne utilisant 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;
}

Pré-requis: vous devez ajouter la référence System.Data.Linq et la référencer

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

J'avais également du mal à obtenir la bonne adresse IP.

J'ai essayé une variété de solutions ici, mais aucune ne m'a fourni l'effet souhaité. Presque tous les tests conditionnels fournis n’ont pas permis d’utiliser d’adresse.

C'est ce qui a fonctionné pour moi, j'espère que cela aide ...

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

Gardez à l'esprit que, dans le cas général, vous pouvez avoir plusieurs traductions NAT en cours et plusieurs serveurs DNS, chacun fonctionnant sur des niveaux de traduction NAT différents.

Que faire si vous avez un NAT de classe opérateur et que vous souhaitez communiquer avec d'autres clients du même opérateur? Dans le cas général, vous ne savez jamais avec certitude car vous pouvez apparaître avec des noms d'hôtes différents à chaque traduction NAT.

Obsolète disparu, cela fonctionne pour moi

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

En mettant à jour la réponse de Mrchief avec Linq, nous aurons:

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

Cela renvoie les adresses de toutes les interfaces qui ont des adresses de passerelle et des adresses de monodiffusion dans deux listes distinctes, IPV4 et 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());
}

Il y a déjà beaucoup de réponses, mais j'apporte toujours la mienne:

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

Bon mot:

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

Remarque: recherchez à partir du dernier car cela fonctionnait toujours après l'ajout de certaines interfaces dans l'appareil, telles que MobileHotspot, VPN ou autres adaptateurs virtuels fantaisistes.

De plus, un code simple pour obtenir Client Ip:

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

J'espère que cela vous aidera.

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

Code de compman2408 modifié pour pouvoir parcourir chacun d'eux 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;
}

Et vous pouvez l'appeler ainsi:

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

En dessous de la même action

Fonction LocalIP ()

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

txtIP.Text = Hôte

Retour vrai

Fonction de fin

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

une ligne de code: D

Si vous avez des machines virtuelles ou des cartes réseau supplémentaires, il peut y avoir d'autres valeurs dans la liste d'adresses. Ma suggestion est de vérifier les entrées de la liste d'adresses et d'imprimer ce qui est approprié. Dans mon cas, l'entrée 3 était l'adresse IPv4 de ma machine

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

N'oubliez pas d'ajouter using System.Net;