使用 .NET 检查 Internet 连接的最佳方法是什么？

Question

在 .NET 中检查 Internet 连接的最快、最有效的方法是什么？

Answer 1

您可以使用此代码，它也应该适用于伊朗和中国 -

public static bool CheckForInternetConnection(int timeoutMs = 10000, string url = null)
{
    try
    {
        url ??= CultureInfo.InstalledUICulture switch
        {
            { Name: var n } when n.StartsWith("fa") => // Iran
                "http://www.aparat.com",
            { Name: var n } when n.StartsWith("zh") => // China
                "http://www.baidu.com",
            _ =>
                "http://www.gstatic.com/generate_204",
        };

        var request = (HttpWebRequest)WebRequest.Create(url);
        request.KeepAlive = false;
        request.Timeout = timeoutMs;
        using (var response = (HttpWebResponse)request.GetResponse())
            return true;
    }
    catch
    {
        return false;
    }
}

Answer 2

您绝对无法可靠检查是否有互联网连接（我假设您的意思是访问互联网）。

但是，您可以请求几乎从不离线的资源，例如 ping google.com 或类似的东西。我认为这会很有效率。

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

Answer 3

无需进行检查，只需执行操作（Web 请求、邮件、FTP 等），并为请求失败做好准备，即使检查成功，您也必须这样做。

请考虑以下事项：

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

如果网络出现故障，您的操作将像 ping 等操作一样快速失败。

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

Answer 4

NetworkInterface.GetIsNetworkAvailable 非常不可靠。只要有一些 VMware 或其他 LAN 连接，它就会返回错误的结果。
另外，关于 Dns.GetHostEntry 方法，我只是担心测试 URL 是否可能在我的应用程序要部署的环境中被阻止。

所以我发现的另一种方法是使用 InternetGetConnectedState 方法。
我的代码是

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

Answer 5

Ping google.com 引入了 DNS 解析依赖性。 Ping 8.8.8.8 没问题，但 Google 离我还差好几跳。我需要做的就是 ping 互联网上离我最近的东西。

我可以使用 Ping 的 TTL 功能来 ping 跳#1，然后跳#2，依此类推，直到我从可路由地址上的某个地址获得回复；如果该节点位于可路由地址上，则它位于互联网上。对于我们大多数人来说，跳#1 将是我们的本地网关/路由器，跳#2 将是光纤连接另一侧的第一个点或其他点。

这段代码对我有用，并且比该线程中的其他一些建议响应得更快，因为它正在 ping 互联网上离我最近的任何地方。

using System.Diagnostics;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Threading.Tasks;
    
public static async Task<bool> IsConnectedToInternetAsync()
{
    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++)
    {
        var options = new PingOptions(ttl, true);
        byte[] buffer = new byte[32];
        PingReply reply;
        try
        {
            using (var pinger = new Ping())
            {
                reply = await pinger.SendPingAsync(someFarAwayIpAddress, 10000, buffer, options);
            }
        }
        catch (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;
        }
    
        string address = reply.Address?.ToString() ?? null;
        Debug.Print($"Hop #{ttl} is {address}, {reply.Status}");
    
        if (reply.Status != IPStatus.TtlExpired && reply.Status != IPStatus.Success)
        {
            Debug.Print($"Hop #{ttl} is {reply.Status}, hence we are not connected.");
            return false;
        }
    
        if (IsRoutableAddress(reply.Address))
        {
            Debug.Print("That's routable, so we 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;
        }
    }
}

Answer 6

通过 ping Google 测试互联网连接：

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

Answer 7

我不同意有人说：“在执行任务之前检查连接有什么意义，因为检查后连接可能会立即丢失”。
当然，作为开发人员，我们承担的许多编程任务都存在一定程度的不确定性，但将不确定性降低到可接受的水平是挑战的一部分。

我最近在制作一个应用程序时遇到了这个问题，该应用程序包含链接到在线图块服务器的映射功能。如果发现缺乏互联网连接，则将禁用此功能。

此页面上的一些响应非常好，但确实导致了很多性能问题，例如挂起，主要是在没有连接的情况下。

在其中一些答案和我的同事的帮助下，这是我最终使用的解决方案：

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

Answer 8

我已经看到了上面列出的所有选项，检查互联网是否可用的唯一可行选项是“Ping”选项。
导入 [DllImport("Wininet.dll")] 和 System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces() 或 NetworkInterface 的任何其他变体> 类在检测网络可用性方面效果不佳。这些方法仅检查网络电缆是否已插入。

“Ping 选项”

if（连接可用）返回 true

if（连接不可用并且网络电缆已插入）返回false

if（网络电缆未插入）抛出异常

网络接口

< code>if（互联网可用）返回 True

if（互联网不可用且网线已插入）返回 True

if（网络电缆未插入）返回 false

[DllImport("Wininet.dll")]

if（互联网可用）返回 True

if（互联网不可用且网线已插入）返回 True

if(网络电缆未插入)返回 false

因此，在 [DllImport("Wininet.dll")] 和 NetworkInterface 的情况下无法知道互联网连接是否可用。

Answer 9

不能解决检查和运行代码之间网络中断的问题
但相当可靠

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

Answer 10

以下是它在 Android 中的实现方式。

作为概念证明，我将此代码翻译为 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
    }
}

Answer 11

简介

在某些情况下，您需要在 Windows 应用程序中使用 C# 代码检查互联网是否可用。可能是在 Windows 窗体中使用互联网下载或上传文件，或者从远程位置的数据库获取一些数据，在这些情况下，必须进行互联网检查。

有一些方法可以使用 C# 从代码隐藏中检查互联网可用性。这里解释了所有这些方法，包括它们的局限性。

1. InternetGetConnectedState(wininet)

'wininet' API 可用于检查本地系统是否具有活动的互联网连接。用于此目的的命名空间是“System.Runtime.InteropServices”，并使用 DllImport 导入 dll“wininet.dll”。之后，创建一个带有 extern static 的布尔变量，其函数名称为 InternetGetConnectedState，并带有两个参数 description 和 returnedValue，如示例中所示。

注意：extern 修饰符用于声明外部实现的方法。当您使用 Interop 服务调用非托管代码时，extern 修饰符的常见用途是与 DllImport 属性一起使用。在这种情况下，该方法也必须声明为静态的。

接下来创建一个名为“IsInternetAvailable”作为布尔值的方法。这
上面的函数将在这个返回互联网的方法中使用
本地系统状态

[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

以下示例使用 GetIsNetworkAvailable 方法来确定网络连接是否可用。

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

备注（根据 MSDN）：如果任何网络接口标记为“启动”并且不是环回或隧道接口，则认为网络连接可用。

在许多情况下，设备或计算机未连接到有用的网络，但仍被视为可用，并且 GetIsNetworkAvailable 将返回 true。例如，如果运行应用程序的设备连接到需要代理的无线网络，但未设置代理，则 GetIsNetworkAvailable 将返回 true。 GetIsNetworkAvailable 返回 true 的另一个示例是，如果应用程序正在连接到集线器或路由器的计算机上运行，​​而集线器或路由器已丢失上游连接。

3. Ping 网络上的主机名

Ping 和 PingReply 类允许应用程序通过获取主机的回复来确定是否可以通过网络访问远程计算机。这些类在 System.Net.NetworkInformation 命名空间中可用。以下示例显示如何 ping 主机。

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

备注（根据 MSDN）：应用程序使用 Ping 类来检测远程计算机是否可访问。网络拓扑可以决定 Ping 是否可以成功联系远程主机。代理、网络地址转换 (NAT) 设备或防火墙的存在和配置可能会阻止 Ping 成功。 Ping 成功仅表明网络上可以到达远程主机；不保证远程主机上存在更高级别的服务（例如 Web 服务器）。

欢迎提出意见/建议。快乐编码......！

Answer 12

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

Answer 13

尝试通过捕获异常来避免测试连接。因为我们确实期望有时我们可能会失去网络连接。

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

Answer 14

我不认为这是不可能的，只是不简单。

我已经构建了类似的东西，是的，它并不完美，但第一步至关重要：检查是否有任何网络连接。 Windows Api 做得并不好，那么为什么不做得更好呢？

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

它非常简单，但确实有助于提高检查质量，特别是当您想要检查各种代理配置时。

因此：

• 检查是否存在网络连接（使其真正良好，甚至可能在出现误报时将日志发送回开发人员以改进 NetworkIsAvailable 功能）
• HTTP Ping
• （在每个代理配置上循环使用 HTTP Ping）

Answer 15

另一种选择是网络列表管理器 API，可用于 Vista 和 Windows 7。MSDN 文章 此处。文章中提供了下载代码示例的链接，您可以通过该链接执行此操作：

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

请务必从 COM 选项卡添加对 Network List 1.0 类型库的引用...，它将显示为 NETWORKLIST。

Answer 16

我个人认为 Anton 和 moffeltje 的答案最好，但我添加了一项检查以排除 VMWare 和其他人设置的虚拟网络。

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

Answer 17

接受的答案很快就会成功，但在没有连接时失败的速度非常慢。所以我想建立一个强大的连接检查，可以更快地失败。

据说并非所有环境都支持 Pinging，因此我从接受的答案开始，并从 此处 添加了一个 WebClient，其中包含自定义超时。你可以选择任何超时，但通过 wifi 连接时，3 秒对我来说有效。我尝试添加快速迭代（1 秒），如果第一个迭代失败，则添加慢速迭代（3 秒）。但这没有意义，因为两次迭代总是失败（未连接时）或总是成功（连接时）。

我正在连接到 AWS，因为我想在连接测试通过时上传文件。

public static class AwsHelpers
{
    public static bool GetCanConnectToAws()
    {
        try
        {
            using (var client = new WebClientWithShortTimeout())
            using (client.OpenRead("https://aws.amazon.com"))
                return true;
        }
        catch
        {
            return false;
        }
    }
}

public class WebClientWithShortTimeout: WebClient
{
    protected override WebRequest GetWebRequest(Uri uri)
    {
        var webRequest = base.GetWebRequest(uri);
        webRequest.Timeout = 5000;
        return webRequest;
    }
}

Answer 18

如果您想在网络/连接发生变化时通知用户/采取行动。
使用 NLM API：

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

• http://www.codeproject.com/Articles/34650/How-to-use-the-Windows-NLM-API-获取通知

Answer 19

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

Answer 20

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

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

Answer 21

多线程版本的 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";
          }
      }
  }

Answer 22

基于 @ChaosPandion 的答案，为了尽可能确保结果正确，您可以包含多个大型网站，例如其他人指出。但是，这应该异步完成，以避免等待时间过长。此外，WebRequest、HttpWebRequest 和 HttpWebResponse 类现在已过时，应由 HttpClient 替换。以下示例考虑了上述情况：

public static async Task<bool> CheckForInternetConnection(TimeSpan? timeoutMs = null, List<string> urls = null)
{
    if (timeoutMs == null)
    {
        timeoutMs = TimeSpan.FromSeconds(10);
    }

    var culture = CultureInfo.InstalledUICulture;
    if (urls == null)
    {
        urls = new List<string>();

        if (culture.Name.StartsWith("fa"))      // Iran
            urls.Add("http://www.aparat.com");
        else if (culture.Name.StartsWith("zh")) // China
            urls.Add("http://www.baidu.com");
        else
        {
            urls.Add("https://www.apple.com/");
            urls.Add("https://www.gstatic.com/generate_204");
        }
    }

    var client = new HttpClient();
    client.Timeout = (TimeSpan)timeoutMs;
    List<Task<string>> tasks = new List<Task<string>>();
    int unresponsiveUrlCount = 0;

    foreach (var url in urls)
    {   
        tasks.Add(client.GetStringAsync(url));             
    }

    Task aggregationTask = null;
    try
    {
        aggregationTask = Task.WhenAll(tasks);
        await aggregationTask;
    }
    catch (Exception)
    {  
        if (aggregationTask?.Exception?.InnerExceptions != null && aggregationTask.Exception.InnerExceptions.Any())
        {
            foreach (var innerEx in aggregationTask.Exception.InnerExceptions)
            {
                unresponsiveUrlCount++;
            }
        }      
    }

    return unresponsiveUrlCount < urls.Count;
}

此方法检查列表中的所有 url，如果它们都无法访问，则返回 false。我添加了苹果的网址，因为在我的情况下它加载得非常快，但它可以替换为任何网址。

Answer 23

使用 NetworkMonitor 监控网络状态和互联网连接。

示例：

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

Answer 24

以下代码对我来说效果很好：

    Shared Function CheckForInternetConnection() As Boolean
    Try
        System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12
        Using client = New WebClient() With {
        .Proxy = Nothing
    }

            Using client.OpenRead("http://clients3.google.com/generate_204")
                Return True
            End Using
        End Using

    Catch
        Return False
    End Try
End Function

Answer 25

对于我的应用程序，我们还通过下载小文件进行测试。

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

还。一些 ISP 可能会使用中间服务器来缓存文件。添加随机未使用的参数，例如。 https://www.microsoft.com/favicon.ico?req=random_number
可以防止缓存。

Answer 26

我在 3g 路由器/调制解调器上使用这些方法时遇到问题，因为如果互联网断开连接，路由器会将页面重定向到其响应页面，因此您仍然会收到蒸汽，并且您的代码认为有互联网。
苹果（或其他）有一个热点检测页面，它总是返回特定的响应。以下示例返回“成功”响应。所以您将完全确定您可以连接互联网并获得真实的响应！

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

Answer 27

我对互联网连接进行了三个测试。

• 参考System.Net和System.Net.Sockets
• 添加以下测试函数：

测试1

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

测试2

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

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

执行测试

如果您创建一个名为 String 和 Boolean 的字典 >CheckList，您可以将每次测试的结果添加到CheckList中。

现在，使用 for...each 循环递归每个 KeyValuePair。

如果 CheckList 包含 Value 为 true，则您知道存在 Internet 连接。

Answer 28

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

那行得通