Uzyskaj lokalny adres IP

W Internecie jest kilka miejsc, które pokazują, jak uzyskać adres IP. I wiele z nich wygląda jak ten przykład:

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

W tym przykładzie otrzymuję kilka adresów IP, ale interesuje mnie tylko ten, który router przypisuje do komputera z programem: adres IP, który dałbym komuś, jeśli chce uzyskać dostęp do folderu współdzielonego na moim komputerze instancja.

Jeśli nie mam połączenia z siecią i jestem podłączony do Internetu bezpośrednio przez modem bez routera, chciałbym otrzymać błąd. Jak mogę sprawdzić, czy mój komputer jest podłączony do sieci za pomocą C # i czy tak jest, aby uzyskać adres IP LAN.

Aby uzyskać lokalny adres IP:

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

Aby sprawdzić, czy masz połączenie czy nie:

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

Istnieje dokładniejszy sposób, gdy na lokalnym komputerze dostępnych jest wiele adresów IP. Connectgniazdo UDP i przeczytaj jego lokalny punkt końcowy:

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

Connectna gnieździe UDP ma następujący efekt: ustawia miejsce docelowe dla Send/ Recv, odrzuca wszystkie pakiety z innych adresów i - właśnie tego używamy - przenosi gniazdo do stanu „połączonego”, ustawia odpowiednie pola. Obejmuje to sprawdzenie istnienia trasy do miejsca docelowego zgodnie z tablicą routingu systemu i odpowiednie ustawienie lokalnego punktu końcowego. Ostatnia część wydaje się być nieudokumentowana oficjalnie, ale wygląda na integralną cechę API gniazd Berkeley (efekt uboczny stanu „podłączonego” UDP), który działa niezawodnie zarówno w systemie Windows, jak i Linux w różnych wersjach i dystrybucjach.

Tak więc ta metoda da adres lokalny, który będzie używany do łączenia się z określonym hostem zdalnym. Nie ustanowiono rzeczywistego połączenia, dlatego określony zdalny adres IP może być nieosiągalny.

Refaktoryzacja kodu Mrcheifa w celu wykorzystania Linq (tj. .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);
}

:)

Wiem, że to może kopać martwego konia, ale może to komuś pomóc. Wszędzie szukałem sposobu na znalezienie mojego lokalnego adresu IP, ale wszędzie tam jest napisane, aby użyć:

Dns.GetHostEntry(Dns.GetHostName());

W ogóle mi się to nie podoba, ponieważ po prostu dostaje wszystkie adresy przypisane do twojego komputera. Jeśli masz wiele interfejsów sieciowych (które robią obecnie prawie wszystkie komputery), nie masz pojęcia, który adres pasuje do którego interfejsu sieciowego. Po przeprowadzeniu wielu badań stworzyłem funkcję, aby użyć klasy NetworkInterface i wyciągnąć z niej informacje. W ten sposób mogę powiedzieć, jaki to jest interfejs (Ethernet, bezprzewodowy, pętla zwrotna, tunel itp.), Czy jest aktywny czy nie, i SOOO znacznie więcej.

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

Teraz, aby uzyskać adres IPv4 połączenia z interfejsem sieci Ethernet:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

Lub twój interfejs bezprzewodowy:

GetLocalIPv4(NetworkInterfaceType.Wireless80211);

Jeśli spróbujesz uzyskać adres IPv4 dla interfejsu bezprzewodowego, ale twój komputer nie ma zainstalowanej karty bezprzewodowej, zwróci tylko pusty ciąg. To samo z interfejsem Ethernet.

Mam nadzieję, że to komuś pomoże! :-)

EDYTOWAĆ:

Zwrócono uwagę (dzięki @NasBanov), że chociaż ta funkcja zajmuje się wyodrębnianiem adresu IP w znacznie lepszy sposób niż używanie Dns.GetHostEntry(Dns.GetHostName())go, nie radzi sobie dobrze z obsługą wielu interfejsów tego samego typu lub wielu adresów IP na jednym interfejsie . Zwróci tylko jeden adres IP, gdy może być przypisanych wiele adresów. Aby zwrócić WSZYSTKIE przypisane adresy, wystarczy manipulować oryginalną funkcją, aby zawsze zwracała tablicę zamiast pojedynczego łańcucha. Na przykład:

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

Teraz ta funkcja zwróci WSZYSTKIE przypisane adresy dla określonego typu interfejsu. Teraz, aby uzyskać tylko jeden ciąg, możesz użyć .FirstOrDefault()rozszerzenia, aby zwrócić pierwszy element w tablicy lub, jeśli jest pusty, zwrócić pusty ciąg.

GetLocalIPv4(NetworkInterfaceType.Ethernet).FirstOrDefault();

Oto zmodyfikowana wersja (z wersji compman2408), która działała dla mnie:

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

Możesz wywołać tę metodę na przykład:

GetLocalIPv4(NetworkInterfaceType.Ethernet);

Zmiana: pobieram adres IP z adaptera, do którego przypisano adres IP bramy. Druga zmiana: dodałem dokumenty i instrukcję break, aby ta metoda była bardziej wydajna.

To najlepszy kod, jaki znalazłem, aby uzyskać bieżący adres IP, unikając hosta VMWare lub innego nieprawidłowego adresu IP.

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

Myślę, że korzystanie z LinQ jest łatwiejsze:

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

Dla śmiechu, pomyślałem, że spróbuję uzyskać pojedynczą instrukcję LINQ za pomocą nowego operatora warunkowego C # 6. Wygląda na dość szalonego i prawdopodobnie okropnie nieefektywnego, ale działa.

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

Logika dzięki uprzejmości Gerardo H(i przez odniesienie compman2408).

Inny sposób uzyskania adresu IP za pomocą wyrażenia 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 Znalazłem tę odpowiedź dzisiaj i była bardzo przydatna, chociaż zwróciła zły adres IP (nie z powodu niedziałającego kodu), ale dała zły adres IP sieci, gdy masz takie rzeczy jak Himachi.

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

Testowany z jedną lub wieloma kartami LAN i maszynami wirtualnymi

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

Tylko zaktualizowana wersja mojego przy użyciu 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;
}

Wymagania wstępne: musisz dodać odwołanie System.Data.Linq i odwołać się do niego

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

Miałem również problemy z uzyskaniem poprawnego adresu IP.

Wypróbowałem tutaj różne rozwiązania, ale żadne nie zapewniło mi pożądanego efektu. Prawie wszystkie dostarczone testy warunkowe nie spowodowały użycia adresu.

To działało dla mnie, mam nadzieję, że to pomaga ...

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

Pamiętaj, że w ogólnym przypadku możesz mieć wiele tłumaczeń NAT i wiele serwerów dns, z których każdy działa na różnych poziomach translacji NAT.

Co zrobić, jeśli masz NAT klasy operatorskiej i chcesz komunikować się z innymi klientami tego samego operatora? W ogólnym przypadku nigdy nie wiadomo na pewno, ponieważ możesz występować z różnymi nazwami hostów przy każdym tłumaczeniu NAT.

Przestarzałe odeszło, to działa dla mnie

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

Aktualizując odpowiedź Mrchiefa za pomocą Linq, będziemy mieli:

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

Zwraca adresy z interfejsów, które mają adresy bram i adresy emisji pojedynczej na dwóch osobnych listach, IPV4 i 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());
}

Jest już wiele odpowiedzi, ale nadal wnoszę swój jeden:

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

Jedna wkładka:

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

Uwaga: Wyszukaj od ostatniego, ponieważ nadal działało po dodaniu niektórych interfejsów do urządzenia, takich jak MobileHotspot, VPN lub innych fantazyjnych kart wirtualnych.

Dodatkowo prosty kod do uzyskania klienta IP:

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

Mam nadzieję, że to ci pomoże.

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

Zmodyfikowano kod compman2408, aby móc iterować po każdym z nich 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;
}

Możesz to tak nazwać:

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

Poniżej tej samej akcji

Funkcja LocalIP ()

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

txtIP.Text = Host

Return True

Funkcja zakończenia

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

jeden wiersz kodu: D

Jeśli masz maszyny wirtualne lub dodatkowe karty sieciowe, na liście adresów mogą znajdować się inne wartości. Moją propozycją jest sprawdzenie wpisów listy adresowej i wydrukowanie, które są odpowiednie. W moim przypadku pozycja 3 to adres IPv4 mojej maszyny

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

Nie zapomnij dodać using System.Net;