Quel est le moyen le plus simple de vérifier qu'une connexion réseau est disponible?

Question

Je suis un peu novice dans le développement de C# /. Net, mais j'ai mis en place une application de suivi des stocks pour un petit ensemble d'actifs dans mon entreprise. J'ai également configuré la base de données à laquelle il se connecte dans SQL 2000.

Actuellement, cela fonctionne très bien lorsqu'une connexion réseau est disponible, mais je souhaite l'étendre pour l'utiliser lorsque je ne suis pas connecté.

Tout d'abord, j'ai besoin de savoir si une connexion est disponible. Alors je mis cela ensemble:

private int availableNetAdapters() 
    { 
     int nicCount = 0; 
     foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces()) 
     { 
      if (nic.OperationalStatus == OperationalStatus.Up) 
      { 
       nicCount++; 
      } 
     } 

     return nicCount; 
    } 

semble fonctionner, mais je dois tester « > 1 » comme quelque chose comme « interface MS TCP Loopback » est toujours détectée indépendamment des autres rassasie de l'adaptateur.

Existe-t-il un moyen meilleur/plus facile de vérifier la connectivité?

G

Answer 1

System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable()

Vous pouvez également utiliser les événements NetworkAvailabilityChanged et NetworkAddressChanged dans cette classe pour surveiller l'adresse IP et les changements de disponibilité du réseau.

EDIT: Sachez que cette méthode vérifie toutes les interfaces réseau disponibles sur l'ordinateur (sans fil, réseau local, etc.). Si quelqu'un d'entre eux est connecté, il reviendra vrai.

Answer 2

Quelques autres choses à retenir:

• avaialable Connexion réseau = connexion Internet.
• accès Internet! = Accès à un site Web spécifique (pensez filtres proxy, ou le site pourrait être simplement vers le bas)

Par conséquent, il est généralement préférable de tester l'accès à la ressource spécifique dont vous avez besoin directement.

Ces ressources sont volatiles; vous devez gérer l'exception quand ils descendent quand même. Il est donc généralement préférable d'aller chercher une ressource comme si vous étiez certain qu'elle existait et de mettre votre temps de développement à faire en sorte que votre gestionnaire d'exceptions fasse un bon travail avec les échecs.

Answer 3

Nous avons une application qui fonctionne principalement dans les voitures de police connectées via des cartes sans fil. Nous avions besoin d'un moyen de déterminer s'ils étaient connectés ou non. Nous avons écrit une très petite classe Ping.cs qui pige un IP ou un nom d'ordinateur prédéterminé à intervalles réguliers. Nous interprétons le message de résultat et modifions l'affichage d'une icône de connexion à la barre d'état système. Si vous voulez, je peux vous envoyer le code C#.

Answer 4

Voici la classe

using System; 
using System.Net; 
using System.Net.Sockets; 
using System.Threading; 
using System.Diagnostics; 

namespace Ping 
{  
    public readonly int iSent = 0; 
    public readonly int iReceived = 0; 
    public readonly int iLost = 0; 

    public PingReceivedArgs (int iSent, int iReceived, int iLost) 
    { 
     this.iSent = iSent; 
     this.iReceived = iReceived; 
     this.iLost = iLost; 
    } 

    public class PingFailedArgs : EventArgs 
    { 
     public readonly int iSent = 0; 
     public readonly int iReceived = 0; 
     public readonly int iLost = 0; 

     public PingFailedArgs (int iSent, int iReceived, int iLost) 
     { 
      this.iSent = iSent; 
      this.iReceived = iReceived; 
      this.iLost = iLost; 
     } 
    } 

/// <summary> 
/// The Main Ping Class 
/// </summary> 
public class Ping 
{ 
     //Create delegate for events 
      public delegate void PingReceivedHandler(object DataObj, PingReceivedArgs PingReceived); 
     public delegate void PingFailedHandler(object DataObj, PingFailedArgs PingFailed); 

    //The events we publish 
    public event PingReceivedHandler OnPingReceived; 
    public event PingFailedHandler OnPingFailed; 

    private void FirePingReceivedEvent(int iSent, int iReceived, int iLost) 
    { 
     PingReceivedArgs NewStatus = new PingReceivedArgs(iSent, iReceived, iLost); 
     if (OnPingReceived != null) 
     { 
      OnPingReceived(this,NewStatus); 
     } 
    } 

    private void FirePingFailedEvent(int iSent, int iReceived, int iLost) 
    { 
     PingFailedArgs NewStatus = new PingFailedArgs(iSent, iReceived, iLost); 
     if (OnPingFailed != null) 
     { 
      OnPingFailed(this,NewStatus); 
     } 
    } 


    private string _Host = ""; 
    private bool _HostFound = false; 
    private int _PingSent = 0; 
    private int _PingReceived = 0; 
    private int _PingLost = 0; 
    private int _PauseBetweenPings = 2000; 
    private Thread _PingThread; 

    public string Host 
    { 
     get { return _Host; } 
     set { _Host = value; } 
    } 
    public bool HostFound 
    { 
     get { return _HostFound; } 
    } 
    public int PingSent 
    { 
     get { return _PingSent; } 
    } 
    public int PingReceived 
    { 
     get { return _PingReceived; } 
    } 
    public int PingLost 
    { 
     get { return _PingLost; } 
    } 

    public int PauseBetweenPings 
    { 
     get { return _PauseBetweenPings; } 
     set { _PauseBetweenPings = value; } 
    } 

    public Ping() 
    { 
     // 
     // TODO: Add constructor logic here 
     // 
    } 

    public void StartPinging() 
    { 
     try 
     { 
      if (_Host.Length == 0) 
      { 
       //LogStatus.WriteLog("Host name is blank, stopping.","Error","StartPinging"); 
       return; 
      } 


       if (_PingThread == null || (_PingThread.ThreadState & (System.Threading.ThreadState.Unstarted | System.Threading.ThreadState.Background)) == 0) 
      { 

       _PingThread = new Thread(new ThreadStart(LoopAndPing)); 
       _PingThread.IsBackground = true; 
       _PingThread.Start(); 
      } 
     } 
     catch(Exception ex)  
     { 
      //LogStatus.WriteErrorLog(ex,"Error","StartPinging"); 
     } 
    } 

    public void StopPinging() 
    { 
     try 
     { 
       if (_PingThread != null && (_PingThread.ThreadState & (System.Threading.ThreadState.Stopped | System.Threading.ThreadState.Aborted | System.Threading.ThreadState.Unstarted | System.Threading.ThreadState.AbortRequested)) == 0) 
      { 
       _PingThread.Abort(); 
       _PingThread.Join(); 
      } 
     } 
     catch (Exception ex) 
     { 
      //LogStatus.WriteErrorLog(ex, "Error", "StopPinging"); 
     } 
    } 

    /// <summary> 
    /// LoopAndPing: Runs from a thread. Basically loops and gathers stats. 
    /// </summary> 
    private void LoopAndPing() 
    { 
     bool bHostFound = false; 

     try 
     { 
      while(true) 
      { 
       _PingSent++; 
       bHostFound = PingHost(_Host); 
       if (bHostFound) 
       { 
        _PingReceived++; 
        _HostFound = true; 
         FirePingReceivedEvent(_PingSent,_PingReceived,_PingLost); 
       } 
       else 
       { 
        _PingLost++; 
        _HostFound = false; 
         FirePingFailedEvent(_PingSent,_PingReceived,_PingLost); 
       } 
       Thread.Sleep(_PauseBetweenPings); 
      } 
     } 
     catch(ThreadAbortException) 
     { 
      //No need to do anything! 
     } 
     catch(Exception e) 
     { 
      //LogStatus.WriteErrorLog(e,"Error","LoopAndPing"); 
     } 
    } 

    /// <summary> 
    /// PingHost - Send one ping to the host 
    /// </summary> 
    /// <param name="host">Can be an IP or Host name.</param> 
    /// <returns></returns> 
    public bool PingHost(string szHost) 
    { 
     bool bPingWorked = false; 

     try 
     { 
      string szCommand = "ping " + szHost + " -n 1"; 
      Process p = new Process(); 
      p.StartInfo.FileName = "cmd.exe"; 
      p.StartInfo.Arguments = "/Q /A /C" + szCommand; 
      p.StartInfo.UseShellExecute = false; 
      p.StartInfo.RedirectStandardOutput = true; 
      p.StartInfo.RedirectStandardError = true; 
      p.StartInfo.CreateNoWindow = true; 
      p.Start(); 
      string szCommandOutput = p.StandardOutput.ReadToEnd(); 
      p.WaitForExit(); 

      if (szCommandOutput.ToUpper().IndexOf("REPLY FROM") > -1) 
      { 
       bPingWorked = true; 
      } 
     } 
     catch(ThreadAbortException) 
     { 
      //No need to do anything! 
     } 
     catch(Exception e) 
     { 
      //LogStatus.WriteErrorLog(e,"Error","PingHost"); 
     } 
     return bPingWorked; 
    } 
} 
} 

à partir du client que vous appelleriez

PingHost = new Ping(); 
PingHost.OnPingFailed += new Ping.PingFailedHandler(PingHost_OnPingFailed); 
PingHost.OnPingReceived +=new Ping.PingReceivedHandler(PingHost_OnPingReceived); 
PingHost.Host = *IP you wish to ping*; 
PingHost.StartPinging(); 

Ensuite, vous coder des méthodes pour capturer les événements de PingHost définis ci-dessus

private void PingHost_OnPingReceived(object DataObj, PingReceivedArgs PingReceived) 
{ 
    try 
    { 
     // code to do something when a successful ping occurrs 
    } 
    catch (Exception ex) 
    { 
     // code to do something when an exception occurrs 
    } 
} 

private void PingHost_OnPingFailed(object DataObj, PingFailedArgs PingFailed) 
{ 
    try 
    { 
      // code to do something when a ping failure occurrs 
    } 
    catch (Exception ex) 
    { 
      // code to do something when an exception occurrs 
    } 
}