Holen Sie sich die lokale IP-Adresse

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, aber ich bin nur daran interessiert, die zu erhalten, die der Router dem Computer zuweist, auf dem das Programm ausgeführt wird: die IP, die ich jemandem geben würde, wenn er auf einen freigegebenen Ordner auf 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 feststellen, ob mein Computer mit C # mit einem Netzwerk verbunden ist und ob dann die LAN-IP-Adresse abgerufen werden soll?

So erhalten Sie die 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();

Es gibt einen genaueren Weg, wenn auf dem lokalen Computer mehrere IP-Adressen verfügbar sind. Connecteinen UDP-Socket und lesen Sie seinen 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();
}

ConnectEin UDP-Socket hat folgenden Effekt: Er legt das Ziel für Send/ fest Recv, verwirft alle Pakete von anderen Adressen und versetzt den Socket - was wir verwenden - in den Status "verbunden" und stellt die entsprechenden Felder ein. Dies umfasst das Überprüfen des Vorhandenseins der Route zum Ziel gemäß der Routing-Tabelle des Systems und das entsprechende Festlegen des lokalen Endpunkts. Der letzte Teil scheint offiziell nicht dokumentiert zu sein, aber es scheint ein integraler Bestandteil der Berkeley-Sockets-API zu sein (ein Nebeneffekt des UDP-Status "verbunden"), der sowohl unter Windows als auch unter Linux über Versionen und Distributionen hinweg zuverlässig funktioniert .

Diese Methode gibt also die lokale Adresse an, die für die Verbindung mit dem angegebenen Remote-Host verwendet wird. Es wurde keine echte Verbindung hergestellt, daher kann die angegebene Remote-IP nicht erreichbar sein.

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

:) :)

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 erhält, die Ihrem Computer zugewiesen sind. Wenn Sie mehrere Netzwerkschnittstellen haben (was heutzutage so gut wie alle Computer tun), wissen Sie nicht, welche Adresse zu welcher Netzwerkschnittstelle gehört. Nachdem ich einige Nachforschungen angestellt hatte, erstellte ich eine Funktion zur Verwendung der NetworkInterface-Klasse und riss die Informationen heraus. 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 viel 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 rufen Sie jetzt die IPv4-Adresse Ihres Ethernet-Netzwerkschnittstellenaufrufs ab:

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! :-)

BEARBEITEN:

Es wurde darauf hingewiesen (danke @NasBanov), dass diese Funktion zwar das Extrahieren der IP-Adresse auf viel bessere Weise als die Verwendung ermöglicht Dns.GetHostEntry(Dns.GetHostName()), jedoch nicht sehr gut mehrere Schnittstellen desselben Typs oder mehrere IP-Adressen auf einer einzigen Schnittstelle unterstützt . Es wird nur eine einzige IP-Adresse zurückgegeben, wenn möglicherweise mehrere Adressen zugewiesen sind. Um ALLE diese zugewiesenen Adressen zurückzugeben, können Sie einfach die ursprüngliche Funktion manipulieren, um immer ein Array anstelle einer einzelnen Zeichenfolge zurückzugeben. 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();
}

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

GetLocalIPv4(NetworkInterfaceType.Ethernet).FirstOrDefault();

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

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

Sie können diese Methode beispielsweise wie folgt aufrufen:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

Die Änderung: Ich rufe die IP von einem Adapter ab, dem eine Gateway-IP zugewiesen ist. Zweite Änderung: Ich habe docstrings und break-Anweisungen hinzugefügt, um diese Methode effizienter zu gestalten.

Dies ist der beste Code, den ich gefunden habe, um die aktuelle IP-Adresse abzurufen, um zu vermeiden, dass ein VMWare-Host oder eine andere ungültige IP-Adresse abgerufen wird.

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

Ich denke, die Verwendung von LinQ ist einfacher:

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

Zum Lachen dachte ich, ich würde versuchen, eine einzelne LINQ-Anweisung zu erhalten, indem ich den neuen nullbedingten C # 6-Operator verwende. 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 durch Bezugnahme compman2408).

Andere Möglichkeit, IP mithilfe des linq-Ausdrucks abzurufen:

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 Ich habe diese Antwort heute gefunden und sie war sehr nützlich, obwohl sie eine falsche IP-Adresse zurückgegeben hat (nicht, weil der Code nicht funktioniert), aber sie hat die falsche IP-Adresse für das Netzwerk angegeben, 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;
}

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

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

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

Ich hatte auch Probleme, die richtige IP zu erhalten.

Ich habe hier verschiedene Lösungen ausprobiert, aber keine hat mir den gewünschten Effekt gebracht. Bei fast allen bereitgestellten bedingten Tests wurde keine Adresse verwendet.

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

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

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

Was ist, wenn Sie über NAT mit Carrier-Qualität verfügen und mit anderen Kunden desselben Carriers kommunizieren möchten? Im Allgemeinen wissen Sie es nie genau, da Sie bei jeder NAT-Übersetzung möglicherweise mit unterschiedlichen Hostnamen angezeigt werden.

Veraltet weg, das funktioniert bei mir

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

Wenn wir die Antwort von Mrchief mit Linq aktualisieren, haben wir:

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

Dies gibt Adressen von allen Schnittstellen zurück, die Gateway-Adressen und Unicast-Adressen in zwei separaten Listen haben, IPV4 und 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());
}

Es gibt bereits viele Antworten, aber ich trage immer noch meine bei:

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

Einzeiler:

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

Hinweis: Suchen Sie nach dem letzten, da es nach einigen dem Gerät hinzugefügten Schnittstellen wie MobileHotspot, VPN oder anderen ausgefallenen virtuellen Adaptern immer noch funktioniert hat.

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

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

Hoffe es hilft dir.

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

Der Code von compman2408 wurde geändert, um ihn jeweils durchlaufen zu können 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;
}

Und man kann es so nennen:

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

Unter der gleichen Aktion

Funktion LocalIP ()

Host als Zeichenfolge dimmen = Dns.GetHostEntry (Dns.GetHostName) .AddressList (1) .MapToIPv4.ToString

txtIP.Text = Host

Geben Sie True zurück

Funktion beenden

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

eine Codezeile: D.

Wenn Sie über virtuelle Maschinen oder zusätzliche Netzwerkkarten verfügen, enthält die Adressliste möglicherweise andere Werte. Mein Vorschlag ist, die Einträge der Adressliste zu überprüfen und entsprechend zu drucken. In meinem Fall war Eintrag 3 die IPv4-Adresse meines Computers

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

Vergiss nicht hinzuzufügen using System.Net;