Vérifiez constamment la connexion Internet

La réponse acceptée à Cette question sur superutilisateur décrit la manière dont les fenêtres détergent si elle a accès au réseau. Vous pouvez utiliser une méthode similaire, mais j'apprendrais un fil séparé lorsque votre application commence à faire le chèque. Demandez aux threads séparés effectuer la vérification de la manière que vous ressentez est la meilleure et soulevez un événement si l'état de la connexion change.

Vous pouvez tester la connectivité Internet en pinging sur un site Web comme: xxx

Si vous n'avez besoin que de savoir si au moins une connexion est disponible, vous pouvez essayer ceci:

InternetgetConnectedstateex ()

http://msdn.microsoft. COM / EN-US / Bibliothèque / AA384705% 28V = vs.85% 29.aspx

Utilisez le code suivant:

public static class LocalSystemConnection
{
    [DllImport("wininet.dll", SetLastError=true, CallingConvention = CallingConvention.ThisCall)]
    extern static bool InternetGetConnectedState(out ConnectionStates lpdwFlags, long dwReserved);

    /// <summary>
    /// Retrieves the connected state of the local system.
    /// </summary>
    /// <param name="connectionStates">A <see cref="ConnectionStates"/> value that receives the connection description.</param>
    /// <returns>
    /// A return value of true indicates that either the modem connection is active, or a LAN connection is active and a proxy is properly configured for the LAN.
    /// A return value of false indicates that neither the modem nor the LAN is connected.
    /// If false is returned, the <see cref="ConnectionStates.Configured"/> flag may be set to indicate that autodial is configured to "always dial" but is not currently active.
    /// If autodial is not configured, the function returns false.
    /// </returns>
    public static bool IsConnectedToInternet(out ConnectionStates connectionStates)
    {
        connectionStates = ConnectionStates.Unknown;
        return InternetGetConnectedState(out connectionStates, 0);
    }

    /// <summary>
    /// Retrieves the connected state of the local system.
    /// </summary>
    /// <returns>
    /// A return value of true indicates that either the modem connection is active, or a LAN connection is active and a proxy is properly configured for the LAN.
    /// A return value of false indicates that neither the modem nor the LAN is connected.
    /// If false is returned, the <see cref="ConnectionStates.Configured"/> flag may be set to indicate that autodial is configured to "always dial" but is not currently active.
    /// If autodial is not configured, the function returns false.
    /// </returns>
    public static bool IsConnectedToInternet()
    {
        ConnectionStates state = ConnectionStates.Unknown;
        return IsConnectedToInternet(out state);
    }
}

[Flags]
public enum ConnectionStates
{
    /// <summary>
    /// Unknown state.
    /// </summary>
    Unknown = 0,

    /// <summary>
    /// Local system uses a modem to connect to the Internet.
    /// </summary>
    Modem = 0x1,

    /// <summary>
    /// Local system uses a local area network to connect to the Internet.
    /// </summary>
    LAN = 0x2,

    /// <summary>
    /// Local system uses a proxy server to connect to the Internet.
    /// </summary>
    Proxy = 0x4,

    /// <summary>
    /// Local system has RAS (Remote Access Services) installed.
    /// </summary>
    RasInstalled = 0x10,

    /// <summary>
    /// Local system is in offline mode.
    /// </summary>
    Offline = 0x20,

    /// <summary>
    /// Local system has a valid connection to the Internet, but it might or might not be currently connected.
    /// </summary>
    Configured = 0x40,
}

Si vous souhaitez vérifier en continu, utilisez la minuterie xxx

Je sais que c'est une vieille question, mais cela fonctionne bien pour moi. XXX PRE>

Je m'abonne à l'événement à un auditeur et vérifie constamment la connexion. Ceci vous pouvez ajouter une instruction IF telle que: P>

if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
   {
        //Send Ping...
   }
else
    {
        //other code....
    }

Ce code sauvera la sauvetage pour vous .. Il vérifie non seulement la vraie connexion Internet mais ne gérait également l'exception avec une indication sur la fenêtre de la console ... Après toutes les 2 secondes xxx

Utilisation du NetworkChange.NetworkAndiapaillabilitéChanged code> est la réponse la plus trompeuse. Il vérifie la modification de la disponibilité du réseau et non la modification de la connexion Internet.

Nous pouvons surveiller la connexion Internet à l'aide de Windows NLM API code>. P>

using System;
using System.Runtime.InteropServices.ComTypes;
using NETWORKLIST;

namespace Components.Network.Helpers
{
    public class InternetConnectionChecker : INetworkListManagerEvents, IDisposable
    {
        private int _cookie;
        private IConnectionPoint _connectionPoint;
        private readonly INetworkListManager _networkListManager;

        public InternetConnectionChecker()
        {
            _networkListManager = new NetworkListManager();
        }

        public bool IsConnected()
        {
            return _networkListManager.IsConnectedToInternet;
        }

        public void StartMonitoringConnection()
        {
            try
            {
                var container = _networkListManager as IConnectionPointContainer;
                if (container == null)
                    throw new Exception("connection container is null");
                var riid = typeof(INetworkListManagerEvents).GUID;
                container.FindConnectionPoint(ref riid, out _connectionPoint);
                _connectionPoint.Advise(this, out _cookie);
            }
            catch (Exception e)
            {

            }
        }

        public void ConnectivityChanged(NLM_CONNECTIVITY newConnectivity)
        {
            if (_networkListManager.IsConnectedToInternet)
            {
                // do something based on internet connectivity
            }

        }

        public void Dispose()
        {
            _connectionPoint.Unadvise(_cookie);
        }
    }
}