Jaki jest najlepszy sposób na sprawdzenie połączenia z Internetem using.NET?

Nie ma absolutnie żadnego sposobu, aby niezawodnie sprawdzić, czy jest połączenie z Internetem, czy nie (zakładam, że masz na myśli dostęp do Internetu).

Możesz jednak zażądać zasobów, które praktycznie nigdy nie są offline, takich jak pingowanie google.com albo coś podobnego. Myślę, że to będzie skuteczne.

try { 
    Ping myPing = new Ping();
    String host = "google.com";
    byte[] buffer = new byte[32];
    int timeout = 1000;
    PingOptions pingOptions = new PingOptions();
    PingReply reply = myPing.Send(host, timeout, buffer, pingOptions);
    return (reply.Status == IPStatus.Success);
}
catch (Exception) {
    return false;
}

Zamiast sprawdzać, po prostu wykonaj akcję (żądanie www, poczta, ftp itp.) i bądź przygotowany na niepowodzenie wniosku, co i tak musisz zrobić, nawet jeśli twój czek się powiódł.

Rozważ co następuje:

1 - check, and it is OK
2 - start to perform action 
3 - network goes down
4 - action fails
5 - lot of good your check did

Jeśli sieć jest wyłączona, twoja akcja nie powiedzie się tak szybko, jak ping itp.

1 - start to perform action
2 - if the net is down(or goes down) the action will fail

NetworkInterface.GetIsNetworkAvailable jest bardzo zawodny. Wystarczy mieć jakieś połączenie VMware lub inne LAN i zwróci zły wynik. Również o metodzie Dns.GetHostEntry martwiłem się, czy testowy adres URL może zostać zablokowany w środowisku, w którym moja aplikacja zostanie wdrożona.

[System.Runtime.InteropServices.DllImport("wininet.dll")]
private extern static bool InternetGetConnectedState(out int Description, int ReservedValue);

public static bool CheckNet()
{
     int desc;
     return InternetGetConnectedState(out desc, 0);         
}

Nie zgadzam się z osobami, które stwierdzają: "jaki jest sens sprawdzania łączności przed wykonaniem zadania, ponieważ natychmiast po sprawdzeniu połączenie może zostać utracone". Z pewnością istnieje pewien stopień niepewności w wielu zadaniach programistycznych, które podejmujemy jako programiści, ale zmniejszenie niepewności do poziomu akceptacji jest częścią wyzwania.

Ostatnio natknąłem się na ten problem tworząc aplikację, która zawiera funkcję mapowania, która łączyła się z serwerem płytek on-line. To funkcjonalność miała zostać wyłączona, gdy zauważono brak połączenia z Internetem.

Niektóre odpowiedzi na tej stronie były bardzo dobre, ale powodowały jednak wiele problemów z wydajnością, takich jak wiszące, głównie w przypadku braku łączności.

Oto rozwiązanie, z którego skorzystałem, z pomocą niektórych z tych odpowiedzi i moich kolegów:

         // Insert this where check is required, in my case program start
         ThreadPool.QueueUserWorkItem(CheckInternetConnectivity);
    }

    void CheckInternetConnectivity(object state)
    {
        if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
        {
            using (WebClient webClient = new WebClient())
            {
                webClient.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.BypassCache);
                webClient.Proxy = null;
                webClient.OpenReadCompleted += webClient_OpenReadCompleted;
                webClient.OpenReadAsync(new Uri("<url of choice here>"));
            }
        }
    }

    volatile bool internetAvailable = false; // boolean used elsewhere in code

    void webClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
    {
        if (e.Error == null)
        {
            internetAvailable = true;
            Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
            {
                // UI changes made here
            }));
        }
    }

Test Połączenia Internetowego przez pingowanie Google:

new Ping().Send("www.google.com.mx").Status == IPStatus.Success

Nie rozwiązuje problemu awarii sieci pomiędzy sprawdzeniem i uruchomieniem kodu ale jest dość wiarygodne

public static bool IsAvailableNetworkActive()
{
    // only recognizes changes related to Internet adapters
    if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
    {
        // however, this will include all adapters -- filter by opstatus and activity
        NetworkInterface[] interfaces = System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces();
        return (from face in interfaces
                where face.OperationalStatus == OperationalStatus.Up
                where (face.NetworkInterfaceType != NetworkInterfaceType.Tunnel) && (face.NetworkInterfaceType != NetworkInterfaceType.Loopback)
                select face.GetIPv4Statistics()).Any(statistics => (statistics.BytesReceived > 0) && (statistics.BytesSent > 0));
    }

    return false;
}

Widziałem wszystkie opcje wymienione powyżej i jedyną realną opcją, aby sprawdzić wither internet jest dostępny lub nie jest opcja" Ping". Importowanie [DllImport("Wininet.dll")] i System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces() lub jakiejkolwiek innej odmiany klasy NetworkInterface nie działa dobrze w wykrywaniu dostępności sieci.Metody te sprawdzają tylko, czy kabel sieciowy jest podłączony, czy nie.

Opcja "ping"

if(połączenie jest dostępne) zwraca true

if(Połączenie nie jest dostępny i kabel sieciowy jest podłączony) zwraca false

if(kabel sieciowy nie jest podłączony) Throws an exception

The NetworkInterface

if(Internet jest dostępny) zwraca True

if(Internet jest niedostępny i kabel sieciowy jest podłączony ) zwraca True

if(kabel sieciowy nie jest podłączony) zwraca false

[DllImport ("Wininet.dll")]

if(Internet Jest dostępne) zwraca True

if(Internet jest niedostępny i kabel sieciowy jest podłączony ) zwraca True

if(kabel sieciowy nie jest podłączony) zwraca false

Tak więc w przypadku [DllImport("Wininet.dll")] i NetworkInterface nie ma możliwości sprawdzenia, czy połączenie z Internetem jest dostępne.

private bool ping()
{
    System.Net.NetworkInformation.Ping pingSender = new System.Net.NetworkInformation.Ping();
    System.Net.NetworkInformation.PingReply reply = pingSender.Send(address);
    if (reply.Status == System.Net.NetworkInformation.IPStatus.Success)
    {                
        return true;
    }
    else
    {                
        return false;
    }
}

Pinging google.com wprowadza zależność od rozdzielczości DNS. Pingowanie 8.8.8.8 jest w porządku, ale Google jest kilka chmieli ode mnie. Wszystko, co muszę zrobić, to pingować najbliższą mi rzecz, która jest w Internecie.

Mogę użyć funkcji TTL Pinga, aby ping hop #1, Potem hop #2, itd., dopóki nie otrzymam odpowiedzi od czegoś, co znajduje się na adresie routowalnym; jeśli ten węzeł jest na adresie routowalnym, to jest w Internecie. Dla większości z nas hop # 1 będzie naszą lokalną bramą / routerem,a hop #2 będzie pierwszy punkt po drugiej stronie naszego połączenia światłowodowego.

Ten kod działa dla mnie i odpowiada szybciej niż niektóre z innych sugestii w tym wątku, ponieważ pinguje to, co jest mi najbliższe w Internecie.

using System.Net;
using System.Net.Sockets;
using System.Net.NetworkInformation;
using System.Diagnostics;

internal static bool ConnectedToInternet()
{
    const int maxHops = 30;
    const string someFarAwayIpAddress = "8.8.8.8";

    // Keep pinging further along the line from here to google 
    // until we find a response that is from a routable address
    for (int ttl = 1; ttl <= maxHops; ttl++)
    {
        Ping pinger = new Ping();
        PingOptions options = new PingOptions(ttl, true);
        byte[] buffer = new byte[32];
        PingReply reply = null;
        try
        {
            reply = pinger.Send(someFarAwayIpAddress, 10000, buffer, options);
        }
        catch (System.Net.NetworkInformation.PingException pingex)
        {
            Debug.Print("Ping exception (probably due to no network connection or recent change in network conditions), hence not connected to internet. Message: " + pingex.Message);
            return false;
        }

        System.Diagnostics.Debug.Print("Hop #" + ttl.ToString() + " is " + (reply.Address == null ? "null" : reply.Address.ToString()) + ", " + reply.Status.ToString());

        if (reply.Status != IPStatus.TtlExpired && reply.Status != IPStatus.Success)
        {
            Debug.Print("Hop #" + ttl.ToString() + " is " + reply.Status.ToString() + ", hence we are not connected.");
            return false;
        }

        if (IsRoutableAddress(reply.Address))
        {
            System.Diagnostics.Debug.Print("That's routable so you must be connected to the internet.");
            return true;
        }
    }

    return false;
}

private static bool IsRoutableAddress(IPAddress addr)
{
    if (addr == null)
    {
        return false;
    }
    else if (addr.AddressFamily == AddressFamily.InterNetworkV6)
    {
        return !addr.IsIPv6LinkLocal && !addr.IsIPv6SiteLocal;
    }
    else // IPv4
    {
        byte[] bytes = addr.GetAddressBytes();
        if (bytes[0] == 10)
        {   // Class A network
            return false;
        }
        else if (bytes[0] == 172 && bytes[1] >= 16 && bytes[1] <= 31)
        {   // Class B network
            return false;
        }
        else if (bytes[0] == 192 && bytes[1] == 168)
        {   // Class C network
            return false;
        }
        else
        {   // None of the above, so must be routable
            return true;
        }
    }
}

Oto Jak to jest zaimplementowane w Androidzie.

Jako dowód koncepcji przetłumaczyłem ten kod do C#:

var request = (HttpWebRequest)WebRequest.Create("http://g.cn/generate_204");
request.UserAgent = "Android";
request.KeepAlive = false;
request.Timeout = 1500;

using (var response = (HttpWebResponse)request.GetResponse())
{
    if (response.ContentLength == 0 && response.StatusCode == HttpStatusCode.NoContent)
    {
        //Connection to internet available
    }
    else
    {
        //Connection to internet not available
    }
}

Inną opcją jest interfejs API Network List Manager, który jest dostępny dla Systemów Vista i Windows 7. Artykuł MSDN Tutaj . W artykule znajduje się link do pobrania próbek kodu, które pozwalają to zrobić:

AppNetworkListUser nlmUser = new AppNetworkListUser();
Console.WriteLine("Is the machine connected to internet? " + nlmUser.NLM.IsConnectedToInternet.ToString());

Pamiętaj, aby dodać odniesienie do biblioteki typu Network List 1.0 z zakładki COM... które pojawią się jako lista sieci.

Osobiście uważam odpowiedź Antona i moffeltje za najlepszą, ale dodałem czek, aby wykluczyć wirtualne sieci skonfigurowane przez VMWare i inne.

public static bool IsAvailableNetworkActive()
{
    // only recognizes changes related to Internet adapters
    if (!System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable()) return false;

    // however, this will include all adapters -- filter by opstatus and activity
    NetworkInterface[] interfaces = System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces();
    return (from face in interfaces
            where face.OperationalStatus == OperationalStatus.Up
            where (face.NetworkInterfaceType != NetworkInterfaceType.Tunnel) && (face.NetworkInterfaceType != NetworkInterfaceType.Loopback)
            where (!(face.Name.ToLower().Contains("virtual") || face.Description.ToLower().Contains("virtual")))
            select face.GetIPv4Statistics()).Any(statistics => (statistics.BytesReceived > 0) && (statistics.BytesSent > 0));
}

Jeśli chcesz powiadomić użytkownika / podjąć działania za każdym razem, gdy nastąpi zmiana sieci / połączenia.
Użyj NLM API:

• Https://msdn.microsoft.com/en-us/library/ee264321.aspx

• Http://www.codeproject.com/Articles/34650/How-to-use-the-Windows-NLM-API-to-get-notified-of

Nie pomyślałbym, że to niemożliwe, tylko nie proste.

Zbudowałem coś takiego i tak nie jest idealnie, ale pierwszy krok jest niezbędny: sprawdzić, czy jest jakaś łączność sieciowa. Interfejs API systemu Windows nie robi Wielkiej roboty, więc dlaczego nie zrobić lepszej pracy?

bool NetworkIsAvailable()
{
    var all = System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces();
    foreach (var item in all)
    {
        if (item.NetworkInterfaceType == NetworkInterfaceType.Loopback)
            continue;
        if (item.Name.ToLower().Contains("virtual") || item.Description.ToLower().Contains("virtual"))
            continue; //Exclude virtual networks set up by VMWare and others
        if (item.OperationalStatus == OperationalStatus.Up)
        {
            return true;
        }
    }

    return false;
}

Jest to dość proste, ale naprawdę pomaga poprawić jakość kontroli, zwłaszcza gdy chcesz sprawdzić różne konfiguracje proxy.

Więc:

• sprawdź, czy jest łączność sieciowa (zrobić to naprawdę dobrze, może nawet mieć dzienniki wysyłane z powrotem do programistów, gdy istnieją fałszywe alarmy, aby poprawić funkcję NetworkIsAvailable) {]}
• HTTP Ping
W przeciwieństwie do innych serwerów Proxy, Serwery Proxy mogą być używane tylko w przypadku serwerów Proxy.]}

public static bool Isconnected = false;

public static bool CheckForInternetConnection()
{
    try
    {
        Ping myPing = new Ping();
        String host = "google.com";
        byte[] buffer = new byte[32];
        int timeout = 1000;
        PingOptions pingOptions = new PingOptions();
        PingReply reply = myPing.Send(host, timeout, buffer, pingOptions);
        if (reply.Status == IPStatus.Success)
        {
            return true;
        }
        else if (reply.Status == IPStatus.TimedOut)
        {
            return Isconnected;
        }
        else
        {
            return false;
        }
    }
    catch (Exception)
    {
        return false;
    }
}

public static void CheckConnection()
{
    if (CheckForInternetConnection())
    {
        Isconnected = true;
    }
    else
    {
        Isconnected = false;
    }
}

bool bb = System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable();

if (bb == true)
    MessageBox.Show("Internet connections are available");
else
    MessageBox.Show("Internet connections are not available");

Wielowątkowa wersja ping:

  using System;
  using System.Collections.Generic;
  using System.Diagnostics;
  using System.Net.NetworkInformation;
  using System.Threading;


  namespace OnlineCheck
  {
      class Program
      {

          static bool isOnline = false;

          static void Main(string[] args)
          {
              List<string> ipList = new List<string> {
                  "1.1.1.1", // Bad ip
                  "2.2.2.2",
                  "4.2.2.2",
                  "8.8.8.8",
                  "9.9.9.9",
                  "208.67.222.222",
                  "139.130.4.5"
                  };

              int timeOut = 1000 * 5; // Seconds


              List<Thread> threadList = new List<Thread>();

              foreach (string ip in ipList)
              {

                  Thread threadTest = new Thread(() => IsOnline(ip));
                  threadList.Add(threadTest);
                  threadTest.Start();
              }

              Stopwatch stopwatch = Stopwatch.StartNew();

              while (!isOnline && stopwatch.ElapsedMilliseconds <= timeOut)
              {
                   Thread.Sleep(10); // Cooldown the CPU
              }

              foreach (Thread thread in threadList)
              { 
                  thread.Abort(); // We love threads, don't we?
              }


              Console.WriteLine("Am I online: " + isOnline.ToYesNo());
              Console.ReadKey();
          }

          static bool Ping(string host, int timeout = 3000, int buffer = 32)
          {
              bool result = false;

              try
              {
                  Ping ping = new Ping();                
                  byte[] byteBuffer = new byte[buffer];                
                  PingOptions options = new PingOptions();
                  PingReply reply = ping.Send(host, timeout, byteBuffer, options);
                  result = (reply.Status == IPStatus.Success);
              }
              catch (Exception ex)
              {

              }

              return result;
          }

          static void IsOnline(string host)
          {
              isOnline =  Ping(host) || isOnline;
          }
      }

      public static class BooleanExtensions
      {
          public static string ToYesNo(this bool value)
          {
              return value ? "Yes" : "No";
          }
      }
  }

Użyj NetworkMonitor do monitorowania stanu sieci i połączenia z Internetem.

Próbka:

namespace AmRoNetworkMonitor.Demo
{
    using System;

    internal class Program
    {
        private static void Main()
        {
            NetworkMonitor.StateChanged += NetworkMonitor_StateChanged;
            NetworkMonitor.StartMonitor();

            Console.WriteLine("Press any key to stop monitoring.");
            Console.ReadKey();
            NetworkMonitor.StopMonitor();

            Console.WriteLine("Press any key to close program.");
            Console.ReadKey();
        }

        private static void NetworkMonitor_StateChanged(object sender, StateChangeEventArgs e)
        {
            Console.WriteLine(e.IsAvailable ? "Is Available" : "Is Not Available");
        }
    }
}

Dla mojej aplikacji testujemy również poprzez pobranie pliku tiny.

string remoteUri = "https://www.microsoft.com/favicon.ico"

WebClient myWebClient = new WebClient();

try
{
    byte[] myDataBuffer = myWebClient.DownloadData (remoteUri);
    if(myDataBuffer.length > 0) // Or add more validate. eg. checksum
    {
        return true;
    }
}
catch
{
    return false;
}

Mam problem z tymi metodami na moim routerze/modemie 3g, ponieważ jeśli internet jest odłączony, router przekierowuje stronę na stronę odpowiedzi, więc nadal dostajesz steam i twój kod myśli, że jest internet. Jabłka (lub inne) mają stronę hot-spot-dedection, która zawsze Zwraca określoną odpowiedź. Poniższa próbka zwraca odpowiedź "Success". Będziesz więc dokładnie pewien, że możesz połączyć się z Internetem i uzyskać prawdziwą odpowiedź !

public static bool CheckForInternetConnection()
{
    try
    {       
        using (var webClient = new WebClient())
        using (var stream = webClient.OpenRead("http://captive.apple.com/hotspot-detect.html"))
        {
            if (stream != null)
            {
                //return true;
                stream.ReadTimeout = 1000;
                using (var reader = new StreamReader(stream, Encoding.UTF8, false))
                {
                    string line;
                    while ((line = reader.ReadLine()) != null)
                    {
                        if (line == "<HTML><HEAD><TITLE>Success</TITLE></HEAD><BODY>Success</BODY></HTML>")
                        {
                            return true;
                        }
                        Console.WriteLine(line);
                    }
                }

            }
            return false;
        }
    }
    catch
    {

    }
    return false;
}

Mam trzy testy połączenia z Internetem.

• odniesienie System.Net i System.Net.Sockets
• dodaj następujące funkcje testowe:

Test 1

public bool IsOnlineTest1()
{
    try
    {
        IPHostEntry dummy = Dns.GetHostEntry("https://www.google.com");
        return true;
    }
    catch (SocketException ex)
    {
        return false;
    }
}

Test 2

public bool IsOnlineTest2()
{
    try
    {
        IPHostEntry dummy = Dns.GetHostEntry("https://www.google.com");
        return true;
    }
    catch (SocketException ex)
    {
        return false;
    }
}

Test 3

public bool IsOnlineTest3()
{
    System.Net.WebRequest req = System.Net.WebRequest.Create("https://www.google.com");
    System.Net.WebResponse resp = default(System.Net.WebResponse);
    try
    {
        resp = req.GetResponse();
        resp.Close();
        req = null;
        return true;
    }
    catch (Exception ex)
    {
        req = null;
        return false;
    }
}

Wykonywanie testów

Jeśli tworzysz Dictionary z String i Boolean o nazwie CheckList, możesz dodać wyniki każdego testu do CheckList.

Teraz, rekurencyjnie przez każdy KeyValuePair używając for...each pętla.

Jeśli CheckList zawiera Value z true, to wiesz, że istnieje połączenie z Internetem.

public static bool HasConnection()
{
    try
    {
        System.Net.IPHostEntry i = System.Net.Dns.GetHostEntry("www.google.com");
        return true;
    }
    catch
    {
        return false;
    }
}

To działa