Wie kann ich mit .NET am besten nach Internetverbindungen suchen?

Was ist der schnellste und effizienteste Weg, um die Internetverbindung in .NET zu überprüfen?

So etwas sollte funktionieren.

System.Net.WebClient

public static bool CheckForInternetConnection()
{
    try
    {
        using (var client = new WebClient())
            using (client.OpenRead("http://google.com/generate_204")) 
                return true; 
    }
    catch
    {
        return false;
    }
}

Es gibt absolut keine Möglichkeit, zuverlässig zu überprüfen, ob eine Internetverbindung besteht oder nicht (ich nehme an, Sie meinen den Zugang zum Internet).

Sie können jedoch Ressourcen anfordern, die praktisch nie offline sind, z. B. Ping an google.com oder ähnliches. Ich denke, das wäre effizient.

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

Anstatt zu prüfen, führen Sie einfach die Aktion aus (Webanforderung, E-Mail, FTP usw.) und bereiten Sie sich darauf vor, dass die Anforderung fehlschlägt. Dies müssen Sie trotzdem tun, auch wenn Ihre Prüfung erfolgreich war.

Folgendes berücksichtigen:

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

Wenn das Netzwerk ausgefallen ist, schlägt Ihre Aktion genauso schnell fehl wie ein Ping usw.

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

NetworkInterface.GetIsNetworkAvailableist sehr unzuverlässig. Haben Sie nur eine VMware- oder eine andere LAN-Verbindung und es wird ein falsches Ergebnis zurückgegeben. Auch über die Dns.GetHostEntryMethode war ich nur besorgt darüber, ob die Test-URL in der Umgebung, in der meine Anwendung bereitgestellt werden soll, blockiert sein könnte.

Ein anderer Weg, den ich herausgefunden habe, ist die Verwendung der InternetGetConnectedStateMethode. Mein Code ist

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

Ein Test für die Internetverbindung durch Ping von Google:

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

Ich bin nicht einverstanden mit Leuten, die sagen: "Was bringt es, vor dem Ausführen einer Aufgabe auf Konnektivität zu prüfen, da die Verbindung unmittelbar nach der Prüfung möglicherweise unterbrochen wird?" Sicherlich gibt es bei vielen Programmieraufgaben, die wir als Entwickler übernehmen, ein gewisses Maß an Unsicherheit, aber die Reduzierung der Unsicherheit auf ein Maß an Akzeptanz ist Teil der Herausforderung.

Ich bin kürzlich auf dieses Problem gestoßen, als ich eine Anwendung erstellt habe, die eine Zuordnungsfunktion enthält, die mit einem Online-Kachelserver verknüpft ist. Diese Funktionalität sollte deaktiviert werden, wenn ein Mangel an Internetverbindung festgestellt wurde.

Einige der Antworten auf dieser Seite waren sehr gut, verursachten jedoch viele Leistungsprobleme wie das Aufhängen, hauptsächlich im Falle fehlender Konnektivität.

Hier ist die Lösung, die ich mithilfe einiger dieser Antworten und meiner Kollegen verwendet habe:

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

Ich habe alle oben aufgeführten Optionen gesehen und die einzige praktikable Option, um zu überprüfen, ob das Internet verfügbar ist oder nicht, ist die Option "Ping". Das Importieren [DllImport("Wininet.dll")]und / System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces() oder eine andere Variante der NetworkInterface Klasse funktioniert nicht gut, um die Verfügbarkeit des Netzwerks zu ermitteln. Diese Methoden prüfen nur, ob das Netzwerkkabel eingesteckt ist oder nicht.

Die "Ping-Option"

if(Verbindung ist verfügbar) wird zurückgegeben true

if(Verbindung ist nicht verfügbar und das Netzwerkkabel ist eingesteckt) kehrt zurück false

if(Netzwerkkabel ist nicht eingesteckt) Throws an exception

Das NetworkInterface

if(Internet ist verfügbar) Rückgabe True

if(Internet ist nicht verfügbar und Netzwerkkabel ist eingesteckt) Rückgabe True

if(Netzwerkkabel ist nicht eingesteckt) wird zurückgegeben false

Der [DllImport ("Wininet.dll")]

if(Internet ist verfügbar) Rückgabe True

if(Internet ist nicht verfügbar und Netzwerkkabel ist eingesteckt) Rückgabe True

if(Netzwerkkabel ist nicht eingesteckt) wird zurückgegeben false

Im Falle von [DllImport("Wininet.dll")] und NetworkInterface Es gibt keine Möglichkeit zu wissen, ob eine Internetverbindung verfügbar ist.

Löst nicht das Problem, dass das Netzwerk zwischen dem Überprüfen und Ausführen Ihres Codes ausfällt, ist aber ziemlich zuverlässig

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

Durch Ping von google.com wird eine Abhängigkeit von der DNS-Auflösung eingeführt. Ping 8.8.8.8 ist in Ordnung, aber Google ist einige Sprünge von mir entfernt. Alles, was ich tun muss, ist, das nächstgelegene im Internet zu pingen.

Ich kann die TTL-Funktion von Ping verwenden, um Hop Nr. 1, dann Hop Nr. 2 usw. zu pingen, bis ich eine Antwort von etwas erhalte, das sich an einer routbaren Adresse befindet. Wenn sich dieser Knoten an einer routbaren Adresse befindet, befindet er sich im Internet. Für die meisten von uns ist Hop Nr. 1 unser lokales Gateway / Router, und Hop Nr. 2 ist der erste Punkt auf der anderen Seite unserer Glasfaserverbindung oder was auch immer.

Dieser Code funktioniert für mich und reagiert schneller als einige der anderen Vorschläge in diesem Thread, da er im Internet pingt, was mir am nächsten ist.

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

So wird es in Android implementiert.

Als Proof of Concept habe ich diesen Code in C # übersetzt:

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

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

Eine weitere Option ist die Network List Manager-API, die für Vista und Windows 7 verfügbar ist. MSDN-Artikel hier . In diesem Artikel finden Sie einen Link zum Herunterladen von Codebeispielen, mit denen Sie Folgendes tun können:

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

Stellen Sie sicher, dass Sie auf der Registerkarte COM einen Verweis auf Network List 1.0 Type Library hinzufügen, der als NETWORKLIST angezeigt wird.

Vermeiden Sie das Testen von Verbindungen, indem Sie die Ausnahme abfangen. weil wir wirklich erwarten, dass wir manchmal die Netzwerkverbindung verlieren können.

 if (NetworkInterface.GetIsNetworkAvailable() &&
     new Ping().Send(new IPAddress(new byte[] { 8, 8, 8, 8 }),2000).Status == IPStatus.Success)
 //is online
 else
 //is offline

Wenn Sie den Benutzer benachrichtigen / Maßnahmen ergreifen möchten, wenn eine Netzwerk- / Verbindungsänderung auftritt.
Verwenden Sie die 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

Ich persönlich finde die Antwort von Anton und moffeltje am besten, aber ich habe eine Überprüfung hinzugefügt, um virtuelle Netzwerke auszuschließen, die von VMWare und anderen eingerichtet wurden.

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

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

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

Multithread-Version von 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";
          }
      }
  }

Ich würde nicht denken, dass es unmöglich ist, nur nicht einfach.

Ich habe so etwas gebaut, und ja, es ist nicht perfekt, aber der erste Schritt ist wichtig: zu überprüfen, ob es eine Netzwerkverbindung gibt. Die Windows-API macht keinen großartigen Job. Warum also nicht einen besseren Job machen?

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

Es ist ziemlich einfach, aber es hilft wirklich, die Qualität der Prüfung zu verbessern, insbesondere wenn Sie verschiedene Proxy-Konfigurationen überprüfen möchten.

So:

• Überprüfen Sie, ob eine Netzwerkverbindung besteht (machen Sie dies wirklich gut, lassen Sie möglicherweise sogar Protokolle an Entwickler zurücksenden, wenn Fehlalarme vorliegen, um die NetworkIsAvailable-Funktion zu verbessern).
• HTTP-Ping
• (Durchlaufen Sie die Proxy-Konfigurationen mit jeweils HTTP-Pings.)

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

Verwenden Sie NetworkMonitor, um den Netzwerkstatus und die Internetverbindung zu überwachen.

Stichprobe:

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

Einführung

In einigen Szenarien müssen Sie mithilfe von C # -Code in Windows-Anwendungen überprüfen, ob das Internet verfügbar ist oder nicht. In diesen Situationen ist es möglicherweise obligatorisch, eine Datei über das Internet in Windows-Formularen herunterzuladen oder hochzuladen oder Daten aus einer Datenbank abzurufen, die sich an einem entfernten Standort befindet.

Es gibt einige Möglichkeiten, die Internetverfügbarkeit mithilfe von C # anhand des dahinter stehenden Codes zu überprüfen. Alle diese Möglichkeiten werden hier einschließlich ihrer Einschränkungen erläutert.

1. InternetGetConnectedState (wininet)

Mit der 'wininet'-API kann überprüft werden, ob das lokale System über eine aktive Internetverbindung verfügt oder nicht. Der dafür verwendete Namespace ist 'System.Runtime.InteropServices' und importiert die DLL 'wininet.dll' mit DllImport. Erstellen Sie anschließend eine boolesche Variable mit extern static mit dem Funktionsnamen InternetGetConnectedState mit zwei Parameter description und reservedValue, wie im Beispiel gezeigt.

Hinweis: Der Modifikator extern wird verwendet, um eine extern implementierte Methode zu deklarieren. Der externe Modifikator wird häufig mit dem DllImport-Attribut verwendet, wenn Sie Interop-Dienste zum Aufrufen von nicht verwaltetem Code verwenden. In diesem Fall muss die Methode auch als statisch deklariert werden.

Erstellen Sie als Nächstes eine Methode mit dem Namen 'IsInternetAvailable' als Booleschen Wert. Die obige Funktion wird bei dieser Methode verwendet, die den Internetstatus des lokalen Systems zurückgibt

[DllImport("wininet.dll")]
private extern static bool InternetGetConnectedState(out int description, int reservedValue);
public static bool IsInternetAvailable()
{
    try
    {
        int description;
        return InternetGetConnectedState(out description, 0);
    }
    catch (Exception ex)
    {
        return false;
    }
}

2. GetIsNetworkAvailable

Im folgenden Beispiel wird mithilfe der GetIsNetworkAvailable-Methode ermittelt, ob eine Netzwerkverbindung verfügbar ist.

if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
{
    System.Windows.MessageBox.Show("This computer is connected to the internet");
}
else
{
    System.Windows.MessageBox.Show("This computer is not connected to the internet");
}

Anmerkungen (gemäß MSDN): Eine Netzwerkverbindung gilt als verfügbar, wenn eine Netzwerkschnittstelle als "up" markiert ist und keine Loopback- oder Tunnelschnittstelle ist.

Es gibt viele Fälle, in denen ein Gerät oder Computer nicht mit einem nützlichen Netzwerk verbunden ist, aber dennoch als verfügbar angesehen wird und GetIsNetworkAvailable true zurückgibt. Wenn beispielsweise das Gerät, auf dem die Anwendung ausgeführt wird, mit einem drahtlosen Netzwerk verbunden ist, für das ein Proxy erforderlich ist, der Proxy jedoch nicht festgelegt ist, gibt GetIsNetworkAvailable true zurück. Ein weiteres Beispiel dafür, wann GetIsNetworkAvailable true zurückgibt, ist, wenn die Anwendung auf einem Computer ausgeführt wird, der mit einem Hub oder Router verbunden ist, auf dem der Hub oder Router die Upstream-Verbindung verloren hat.

3. Pingen Sie einen Hostnamen im Netzwerk

Mit den Klassen Ping und PingReply kann eine Anwendung ermitteln, ob auf einen Remotecomputer über das Netzwerk zugegriffen werden kann, indem sie eine Antwort vom Host erhält. Diese Klassen sind im System.Net.NetworkInformation-Namespace verfügbar. Das folgende Beispiel zeigt, wie Sie einen Host anpingen.

protected bool CheckConnectivity(string ipAddress)
{
    bool connectionExists = false;
    try
    {
        System.Net.NetworkInformation.Ping pingSender = new System.Net.NetworkInformation.Ping();
        System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions();
        options.DontFragment = true;
        if (!string.IsNullOrEmpty(ipAddress))
        {
            System.Net.NetworkInformation.PingReply reply = pingSender.Send(ipAddress);
            connectionExists = reply.Status == 
System.Net.NetworkInformation.IPStatus.Success ? true : false;
        }
    }
    catch (PingException ex)
    {
        Logger.LogException(ex.Message, ex);
    }
    return connectionExists;
}

Anmerkungen (gemäß MSDN): Anwendungen verwenden die Ping-Klasse, um festzustellen, ob ein Remotecomputer erreichbar ist. Die Netzwerktopologie kann bestimmen, ob Ping erfolgreich einen Remote-Host kontaktieren kann. Das Vorhandensein und die Konfiguration von Proxys, NAT-Geräten (Network Address Translation) oder Firewalls kann den Erfolg von Ping verhindern. Ein erfolgreicher Ping zeigt nur an, dass der Remote-Host im Netzwerk erreichbar ist. Das Vorhandensein von Diensten höherer Ebene (z. B. eines Webservers) auf dem Remote-Host kann nicht garantiert werden.

Kommentare / Vorschläge sind eingeladen. Viel Spaß beim Codieren ......!

Für meine Anwendung testen wir auch per Download winzige Datei.

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

Ebenfalls. Einige ISPs verwenden möglicherweise den mittleren Server, um Dateien zwischenzuspeichern. Fügen Sie zufällige nicht verwendete Parameter hinzu, z. https://www.microsoft.com/favicon.ico?req=random_number Kann das Caching verhindern.

Ich habe Probleme mit dieser Methode auf meinem 3G-Router / Modem, da der Router die Seite auf die Antwortseite umleitet, wenn das Internet nicht verbunden ist, sodass Sie immer noch Dampf bekommen und Ihr Code denkt, dass es Internet gibt. Äpfel (oder andere) haben eine Hot-Spot-Seite, die immer eine bestimmte Antwort zurückgibt. Das folgende Beispiel gibt die Antwort "Erfolg" zurück. Sie werden also genau sicher sein, dass Sie eine Verbindung zum Internet herstellen und eine echte Antwort erhalten können!

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

Ich habe drei Tests für eine Internetverbindung.

• Referenz System.NetundSystem.Net.Sockets
• Fügen Sie die folgenden Testfunktionen hinzu:

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

Durchführen der Tests

Wenn Sie ein Dictionaryvon erstellen Stringund Booleanaufrufen CheckList, können Sie die Ergebnisse jedes Tests hinzufügen CheckList.

Führen Sie nun jede Schleife KeyValuePairmit einer for...eachSchleife durch.

Wenn CheckListein Valuevon enthält true, wissen Sie, dass eine Internetverbindung besteht.

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

Das funktioniert