it-swarm.com.de

Lokale IP-Adresse abrufen

Im Internet gibt es mehrere Stellen, die Ihnen zeigen, wie Sie eine IP-Adresse erhalten. Und viele von ihnen sehen wie folgt aus:

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

In diesem Beispiel erhalte ich mehrere IP-Adressen, möchte jedoch nur die IP-Adresse ermitteln, die der Router dem Computer zugewiesen hat, auf dem das Programm ausgeführt wird: die IP-Adresse, die ich jemandem geben würde, wenn er auf einen freigegebenen Ordner in meinem Computer zugreifen möchte Beispiel.

Wenn ich nicht mit einem Netzwerk verbunden bin und über ein Modem ohne Router direkt mit dem Internet verbunden bin, möchte ich eine Fehlermeldung erhalten. Wie kann ich sehen, ob mein Computer mit C # an ein Netzwerk angeschlossen ist und ob es dann um die LAN-IP-Adresse geht.

252
Tono Nam

So erhalten Sie eine lokale IP-Adresse:

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

So überprüfen Sie, ob Sie verbunden sind oder nicht:

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

411
Mrchief

Es gibt eine genauere Möglichkeit, wenn auf dem lokalen Computer mehrere IP-Adressen verfügbar sind. Connect einen UDP-Socket und lese dessen lokalen Endpunkt:

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 auf einem UDP-Socket hat folgende Auswirkung: Es legt das Ziel für Send/Recv fest, verwirft alle Pakete von anderen Adressen und überträgt - was wir verwenden - den Socket in "verbundener" Zustand, stellt die entsprechenden Felder ein. Dies beinhaltet die Überprüfung der Existenz der Route zum Ziel gemäß der Routing-Tabelle des Systems und die entsprechende Einstellung des lokalen Endpunkts. Der letzte Teil scheint offiziell undokumentiert zu sein, aber es sieht nach einem integralen Merkmal der Berkeley-Sockets-API aus (ein Nebeneffekt des UDP-Status "Verbunden"), der funktioniert zuverlässig in Windows und Linux über Versionen und Distributionen.

Diese Methode gibt also die lokale Adresse an, die zum Herstellen einer Verbindung mit dem angegebenen Remote-Host verwendet wird. Es besteht keine echte Verbindung, daher ist die angegebene Remote-IP möglicherweise nicht erreichbar.

185

Überarbeitung des Mrcheif-Codes zur Nutzung von Linq (z. B. .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);
}

:)

104
Pure.Krome

Ich weiß, dass dies ein totes Pferd treten kann, aber vielleicht kann dies jemandem helfen. Ich habe überall nach einer Möglichkeit gesucht, meine lokale IP-Adresse zu finden, aber überall, wo ich sie finde, heißt es:

Dns.GetHostEntry(Dns.GetHostName());

Ich mag das überhaupt nicht, weil es nur alle Adressen bekommt, die Ihrem Computer zugewiesen sind. Wenn Sie mehrere Netzwerkschnittstellen haben (was heutzutage so ziemlich alle Computer tun), wissen Sie nicht, welche Adresse zu welcher Netzwerkschnittstelle gehört. Nach einigen Recherchen habe ich eine Funktion erstellt, um die NetworkInterface-Klasse zu verwenden und die Informationen daraus herauszuziehen. Auf diese Weise kann ich feststellen, um welche Art von Schnittstelle es sich handelt (Ethernet, Wireless, Loopback, Tunnel usw.), ob sie aktiv ist oder nicht und SOOO vieles mehr.

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

So ermitteln Sie die IPv4-Adresse Ihres Ethernet-Netzwerkschnittstellenaufrufs:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

Oder Ihre drahtlose Schnittstelle:

GetLocalIPv4(NetworkInterfaceType.Wireless80211);

Wenn Sie versuchen, eine IPv4-Adresse für eine drahtlose Schnittstelle abzurufen, auf Ihrem Computer jedoch keine drahtlose Karte installiert ist, wird nur eine leere Zeichenfolge zurückgegeben. Gleiches gilt für die Ethernet-Schnittstelle.

Hoffe das hilft jemandem! :-)

EDIT:

Es wurde darauf hingewiesen (danke an @NasBanov), dass diese Funktion zwar die IP-Adresse viel besser extrahiert als die Verwendung von Dns.GetHostEntry(Dns.GetHostName()), aber nicht sehr gut mehrere Schnittstellen desselben Typs oder mehrerer IPs unterstützt Adressen auf einer einzigen Schnittstelle. Es wird nur eine einzelne IP-Adresse zurückgegeben, wenn möglicherweise mehrere Adressen zugewiesen sind. Um ALLE dieser zugewiesenen Adressen zurückzugeben, können Sie einfach die ursprüngliche Funktion so manipulieren, dass immer ein Array anstelle einer einzelnen Zeichenfolge zurückgegeben wird. Zum Beispiel:

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

Jetzt gibt diese Funktion ALLE zugewiesenen Adressen für einen bestimmten Schnittstellentyp zurück. Um nur eine einzelne Zeichenfolge abzurufen, können Sie die Erweiterung .FirstOrDefault() verwenden, um das erste Element im Array zurückzugeben, oder, wenn es leer ist, eine leere Zeichenfolge zurückgeben.

GetLocalIPv4(NetworkInterfaceType.Ethernet).FirstOrDefault();
93
compman2408

Hier ist eine modifizierte Version (von compman2408), die für mich funktioniert hat:

internal static string GetLocalIPv4(NetworkInterfaceType _type)
{
    string output = "";
    foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
    {
        if (item.NetworkInterfaceType == _type && item.OperationalStatus == OperationalStatus.Up)
        {
            IPInterfaceProperties adapterProperties = item.GetIPProperties();

            if (adapterProperties.GatewayAddresses.FirstOrDefault() != null)
            {
                foreach (UnicastIPAddressInformation ip in adapterProperties.UnicastAddresses)
                {
                    if (ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                    {
                        output = ip.Address.ToString();
                    }
                }
            }
        }
    }

    return output;
}

Die Änderung: Ich rufe die IP von einem Adapter ab, dem eine Gateway-IP zugewiesen ist.

25
Gerardo H

Dies ist der beste Code, den ich gefunden habe, um die aktuelle IP-Adresse abzurufen, ohne VMWare-Host oder eine andere ungültige IP-Adresse abzurufen.

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()
        : "";
}
18
rodcesar.santos

Ich denke, die Verwendung von LinQ ist einfacher:

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

Zum Lachen, dachte ich, würde versuchen, eine einzelne LINQ-Anweisung mit dem neuen C # 6-Null-Bedingungsoperator zu erhalten. Sieht ziemlich verrückt und wahrscheinlich schrecklich ineffizient aus, aber es funktioniert.

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

Logik mit freundlicher Genehmigung von Gerardo H (und mit Verweis compman2408).

6
Stajs

@mrcheif Ich fand diese Antwort heute und sie war sehr nützlich, obwohl sie eine falsche IP zurückgab (nicht aufgrund des nicht funktionierenden Codes), aber sie gab die falsche Internet-IP, wenn Himachi ausgeführt wird.

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;
}
4
Jordan Trainor

Getestet mit einer oder mehreren LAN-Karten und virtuellen Maschinen

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

Ein anderer Weg, um IP mit linq expression zu erhalten:

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

Voraussetzungen: Sie müssen die System.Data.Linq-Referenz hinzufügen und darauf verweisen

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

Nur eine aktualisierte Version von mir mit 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;
}
1
Giusepe

Ich kämpfte auch mit dem Erhalten der korrekten IP.

Ich habe hier verschiedene Lösungen ausprobiert, aber keine hat mir den gewünschten Effekt verschafft. Fast alle der bereitgestellten bedingten Tests führten dazu, dass keine Adresse verwendet wurde.

Das hat bei mir funktioniert, hoffe es hilft ...

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);
1
UberBiza

Wenn wir Mrchiefs Antwort mit Linq aktualisieren, werden wir Folgendes haben:

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

Denken Sie daran, dass im Allgemeinen mehrere NAT Übersetzungen ausgeführt werden können und mehrere DNS-Server, die jeweils auf unterschiedlichen NAT Übersetzungsstufen ausgeführt werden.

Was ist, wenn Sie ein NAT mit Carrier-Qualität haben und mit anderen Kunden desselben Carriers kommunizieren möchten? Im Allgemeinen wissen Sie es nie genau, da Sie bei jeder Übersetzung von NAT unter Umständen mit unterschiedlichen Hostnamen auftreten.

1
sgjsfth sthseth

Veraltet gegangen, das funktioniert bei mir

public static IPAddress GetIPAddress()
{ 
 IPAddress ip = Dns.GetHostAddresses(Dns.GetHostName()).Where(address => 
 address.AddressFamily == AddressFamily.InterNetwork).First();
 return ip;
}
1
Sourcephy
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();
1
Naimish Mungara

Außerdem nur einfacher Code zum Abrufen von Client-IP:

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

Hoffe es hilft dir.

0
Majedur Rahaman