Ping Classe

Définition

Permet à une application de déterminer si un ordinateur distant est accessible sur le réseau.

public ref class Ping : System::ComponentModel::Component
public ref class Ping : IDisposable
public ref class Ping : System::ComponentModel::Component, IDisposable
public class Ping : System.ComponentModel.Component
public class Ping : IDisposable
public class Ping : System.ComponentModel.Component, IDisposable
type Ping = class
    inherit Component
type Ping = class
    interface IDisposable
type Ping = class
    inherit Component
    interface IDisposable
Public Class Ping
Inherits Component
Public Class Ping
Implements IDisposable
Public Class Ping
Inherits Component
Implements IDisposable
Héritage
Héritage
Ping
Implémente

Exemples

L’exemple de code suivant illustre l’utilisation de la Ping classe de manière synchrone.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::NetworkInformation;
using namespace System::Text;

// args[1] can be an IPaddress or host name.
int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   
   Ping ^ pingSender = gcnew Ping;
   PingOptions ^ options = gcnew PingOptions;
   
   // Use the default Ttl value which is 128,
   // but change the fragmentation behavior.
   options->DontFragment = true;
   
   // Create a buffer of 32 bytes of data to be transmitted.
   String^ data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   array<Byte>^buffer = Encoding::ASCII->GetBytes( data );
   int timeout = 120;
   PingReply ^ reply = pingSender->Send( args[ 1 ], timeout, buffer, options );
   
   if ( reply->Status == IPStatus::Success )
   {
      Console::WriteLine( "Address: {0}", reply->Address->ToString() );
      Console::WriteLine( "RoundTrip time: {0}", reply->RoundtripTime );
      Console::WriteLine( "Time to live: {0}", reply->Options->Ttl );
      Console::WriteLine( "Don't fragment: {0}", reply->Options->DontFragment );
      Console::WriteLine( "Buffer size: {0}", reply->Buffer->Length );
   }

   
}
using System;
using System.Net;
using System.Net.NetworkInformation;
using System.Text;

namespace Examples.System.Net.NetworkInformation.PingTest
{
    public class PingExample
    {
        // args[0] can be an IPaddress or host name.
        public static void Main (string[] args)
        {
            Ping pingSender = new Ping ();
            PingOptions options = new PingOptions ();

            // Use the default Ttl value which is 128,
            // but change the fragmentation behavior.
            options.DontFragment = true;

            // Create a buffer of 32 bytes of data to be transmitted.
            string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
            byte[] buffer = Encoding.ASCII.GetBytes (data);
            int timeout = 120;
            PingReply reply = pingSender.Send (args[0], timeout, buffer, options);
            if (reply.Status == IPStatus.Success)
            {
                Console.WriteLine ("Address: {0}", reply.Address.ToString ());
                Console.WriteLine ("RoundTrip time: {0}", reply.RoundtripTime);
                Console.WriteLine ("Time to live: {0}", reply.Options.Ttl);
                Console.WriteLine ("Don't fragment: {0}", reply.Options.DontFragment);
                Console.WriteLine ("Buffer size: {0}", reply.Buffer.Length);
            }
        }
    }
}

L’exemple de code suivant illustre l’utilisation asynchrone de la Ping classe.

#using <System.dll>

using namespace System;
using namespace System::Text;
using namespace System::Net;
using namespace System::Net::NetworkInformation;
using namespace System::ComponentModel;
using namespace System::Threading;
void PingCompletedCallback( Object^ sender, PingCompletedEventArgs^ e );
void DisplayReply( PingReply^ reply );
int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   if ( args->Length == 1 )
      throw gcnew ArgumentException( "Ping needs a host or IP Address." );

   String^ who = args[ 1 ];
   AutoResetEvent^ waiter = gcnew AutoResetEvent( false );
   
   Ping ^ pingSender = gcnew Ping;
   
   // When the PingCompleted event is raised,
   // the PingCompletedCallback method is called.
   pingSender->PingCompleted += gcnew PingCompletedEventHandler( PingCompletedCallback );
   
   // Create a buffer of 32 bytes of data to be transmitted.
   String^ data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   array<Byte>^buffer = Encoding::ASCII->GetBytes( data );
   
   // Wait 12 seconds for a reply.
   int timeout = 12000;
   
   // Set options for transmission:
   // The data can go through 64 gateways or routers
   // before it is destroyed, and the data packet
   // cannot be fragmented.
   PingOptions ^ options = gcnew PingOptions( 64,true );
   Console::WriteLine( "Time to live: {0}", options->Ttl );
   Console::WriteLine( "Don't fragment: {0}", options->DontFragment );
   
   // Send the ping asynchronously.
   // Use the waiter as the user token.
   // When the callback completes, it can wake up this thread.
   pingSender->SendAsync( who, timeout, buffer, options, waiter );
   
   // Prevent this example application from ending.
   // A real application should do something useful
   // when possible.
   waiter->WaitOne();
   Console::WriteLine( "Ping example completed." );
}


void PingCompletedCallback( Object^ /*sender*/, PingCompletedEventArgs^ e )
{
   
   // If the operation was canceled, display a message to the user.
   if ( e->Cancelled )
   {
      Console::WriteLine( "Ping canceled." );
      
      // Let the main thread resume. 
      // UserToken is the AutoResetEvent object that the main thread 
      // is waiting for.
      (dynamic_cast<AutoResetEvent^>(e->UserState))->Set();
   }

   
   // If an error occurred, display the exception to the user.
   if ( e->Error != nullptr )
   {
      Console::WriteLine( "Ping failed:" );
      Console::WriteLine( e->Error->ToString() );
      
      // Let the main thread resume. 
      (dynamic_cast<AutoResetEvent^>(e->UserState))->Set();
   }

   PingReply ^ reply = e->Reply;
   DisplayReply( reply );
   
   // Let the main thread resume.
   (dynamic_cast<AutoResetEvent^>(e->UserState))->Set();
}


void DisplayReply( PingReply ^ reply )
{
   if ( reply == nullptr )
      return;

   Console::WriteLine( "ping status: {0}", reply->Status );
   if ( reply->Status == IPStatus::Success )
   {
      Console::WriteLine( "Address: {0}", reply->Address->ToString() );
      Console::WriteLine( "RoundTrip time: {0}", reply->RoundtripTime );
      Console::WriteLine( "Time to live: {0}", reply->Options->Ttl );
      Console::WriteLine( "Don't fragment: {0}", reply->Options->DontFragment );
      Console::WriteLine( "Buffer size: {0}", reply->Buffer->Length );
   }
}
using System;
using System.Text;
using System.Net;
using System.Net.NetworkInformation;
using System.ComponentModel;
using System.Threading;

namespace Examples.System.Net.NetworkInformation.PingTest
{
    public class PingExample
    {
        public static void Main (string[] args)
        {
            if (args.Length == 0)
                throw new ArgumentException ("Ping needs a host or IP Address.");

            string who = args[0];
            AutoResetEvent waiter = new AutoResetEvent (false);

            Ping pingSender = new Ping ();

            // When the PingCompleted event is raised,
            // the PingCompletedCallback method is called.
            pingSender.PingCompleted += new PingCompletedEventHandler (PingCompletedCallback);

            // Create a buffer of 32 bytes of data to be transmitted.
            string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
            byte[] buffer = Encoding.ASCII.GetBytes (data);

            // Wait 12 seconds for a reply.
            int timeout = 12000;

            // Set options for transmission:
            // The data can go through 64 gateways or routers
            // before it is destroyed, and the data packet
            // cannot be fragmented.
            PingOptions options = new PingOptions (64, true);

            Console.WriteLine ("Time to live: {0}", options.Ttl);
            Console.WriteLine ("Don't fragment: {0}", options.DontFragment);

            // Send the ping asynchronously.
            // Use the waiter as the user token.
            // When the callback completes, it can wake up this thread.
            pingSender.SendAsync(who, timeout, buffer, options, waiter);

            // Prevent this example application from ending.
            // A real application should do something useful
            // when possible.
            waiter.WaitOne ();
            Console.WriteLine ("Ping example completed.");
        }

        private static void PingCompletedCallback (object sender, PingCompletedEventArgs e)
        {
            // If the operation was canceled, display a message to the user.
            if (e.Cancelled)
            {
                Console.WriteLine ("Ping canceled.");

                // Let the main thread resume.
                // UserToken is the AutoResetEvent object that the main thread
                // is waiting for.
                ((AutoResetEvent)e.UserState).Set ();
            }

            // If an error occurred, display the exception to the user.
            if (e.Error != null)
            {
                Console.WriteLine ("Ping failed:");
                Console.WriteLine (e.Error.ToString ());

                // Let the main thread resume.
                ((AutoResetEvent)e.UserState).Set();
            }

            PingReply reply = e.Reply;

            DisplayReply (reply);

            // Let the main thread resume.
            ((AutoResetEvent)e.UserState).Set();
        }

        public static void DisplayReply (PingReply reply)
        {
            if (reply == null)
                return;

            Console.WriteLine ("ping status: {0}", reply.Status);
            if (reply.Status == IPStatus.Success)
            {
                Console.WriteLine ("Address: {0}", reply.Address.ToString ());
                Console.WriteLine ("RoundTrip time: {0}", reply.RoundtripTime);
                Console.WriteLine ("Time to live: {0}", reply.Options.Ttl);
                Console.WriteLine ("Don't fragment: {0}", reply.Options.DontFragment);
                Console.WriteLine ("Buffer size: {0}", reply.Buffer.Length);
            }
        }
    }
}

Remarques

Les applications utilisent la Ping classe pour détecter si un ordinateur distant est accessible.

La topologie réseau peut déterminer si Ping elle peut contacter un hôte distant. La présence et la configuration des proxys, de l’équipement NAT (Network Address Translation) ou des pare-feu peuvent empêcher Ping de réussir. Une réussite Ping indique uniquement que l’hôte distant peut être atteint sur le réseau ; la présence de services de niveau supérieur (par exemple, un serveur web) sur l’hôte distant n’est pas garantie.

Cette classe fournit des fonctionnalités similaires à l’outil de ligne de commande Ping.exe. Les Send méthodes et SendAsync méthodes envoient un message de demande d’écho ICMP (Internet Control Message Protocol) à un ordinateur distant et attend un message de réponse d’écho ICMP à partir de cet ordinateur. Pour obtenir une description détaillée des messages ICMP, consultez RFC 792, disponible à l’adresse https://www.ietf.org.

Les types suivants sont utilisés avec la Ping classe et sont décrits en détail ci-dessous.

Nom de type Description
IPStatus Définit les codes d’état qui décrivent le résultat d’un message de demande d’écho ICMP.
PingOptions Vous permet de configurer ou de récupérer les paramètres qui contrôlent le nombre de fois où le paquet de requête peut être transféré (Ttl) et s’il peut être fragmenté (DontFragment ).
PingReply Contient les résultats d’une requête d’écho ICMP.
PingException Levée si une erreur irrécupérable se produit.
PingCompletedEventArgs Contient les données associées aux PingCompleted événements, qui sont déclenchées lorsqu’un SendAsync appel est terminé ou annulé.
PingCompletedEventHandler Délégué qui fournit la méthode de rappel appelée lorsqu’un SendAsync appel est terminé ou annulé.

Les Send méthodes et SendAsync les méthodes retournent la réponse dans un PingReply objet. La PingReply.Status propriété retourne une IPStatus valeur pour indiquer le résultat de la requête.

Lors de l’envoi de la demande, vous devez spécifier l’ordinateur distant. Pour ce faire, vous pouvez fournir une chaîne de nom d’hôte, une adresse IP au format de chaîne ou un IPAddress objet.

Vous pouvez également spécifier l’un des types d’informations suivants :

  • Données qui accompagnent la demande. La spécification buffer vous permet d’apprendre le temps nécessaire à un paquet d’une taille particulière pour voyager vers et depuis l’hôte distant et l’unité de transmission maximale du chemin d’accès réseau. (Consultez les Send SendAsync surcharges qui prennent un buffer paramètre.)

  • Indique si le paquet d’écho ICMP peut être fragmenté en transit. (Consultez la DontFragment propriété et les Send SendAsync surcharges qui prennent un options paramètre.)

  • Combien de fois les nœuds de routage, tels que les routeurs ou les passerelles, peuvent transférer le paquet avant qu’il atteigne l’ordinateur de destination ou qu’il soit ignoré. (Voir Ttl et les Send SendAsync surcharges qui prennent un options paramètre.)

  • Délai dans lequel la réponse doit être reçue. (Consultez les Send SendAsync surcharges qui prennent un timeout paramètre.

La Ping classe offre à la fois des méthodes synchrones et asynchrones pour l’envoi de la requête. Si votre application doit bloquer en attendant une réponse, utilisez les Send méthodes ; ces méthodes sont synchrones. Si votre application ne doit pas bloquer, utilisez les méthodes asynchrones SendAsync . Appel à SendAsync exécuter dans son propre thread qui est automatiquement alloué à partir du pool de threads. Une fois l’opération asynchrone terminée, elle déclenche l’événement PingCompleted . Les applications utilisent un PingCompletedEventHandler délégué pour spécifier la méthode appelée pour PingCompleted les événements. Vous devez ajouter un PingCompletedEventHandler délégué à l’événement avant d’appeler SendAsync. La méthode du délégué reçoit un objet qui contient un PingCompletedEventArgs PingReply objet qui décrit le résultat de l’appel SendAsync .

Vous ne pouvez pas utiliser la même instance de la Ping classe pour générer plusieurs demandes d’écho ICMP simultanées. L’appel Send pendant qu’un SendAsync appel est en cours ou en cours d’appel SendAsync plusieurs fois avant que tous les appels précédents n’aient terminé provoque une InvalidOperationException.

Constructeurs

Ping()

Initialise une nouvelle instance de la classe Ping.

Propriétés

CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.

(Hérité de Component)
Container

Obtient le IContainer qui contient la Component.

(Hérité de Component)
DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.

(Hérité de Component)
Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.

(Hérité de Component)
Site

Obtient ou définit le ISite de Component.

(Hérité de Component)

Méthodes

CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
Dispose()

Libère les ressources non managées et supprime les ressources managées utilisées par le Ping.

Dispose()

Libère toutes les ressources utilisées par Component.

(Hérité de Component)
Dispose(Boolean)

Libère les ressources non managées utilisées par l’objet Ping et supprime éventuellement les ressources managées.

Dispose(Boolean)

Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées.

(Hérité de Component)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.

(Hérité de Component)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
OnPingCompleted(PingCompletedEventArgs)

Déclenche l’événement PingCompleted.

Send(IPAddress)

Essaie d’envoyer un message ICMP d’écho à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur.

Send(IPAddress, Int32)

Essaie d’envoyer un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette méthode vous permet de spécifier une valeur de délai d’attente pour l’opération.

Send(IPAddress, Int32, Byte[])

Essaie d’envoyer un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

Send(IPAddress, Int32, Byte[], PingOptions)

Essaie d’envoyer un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération et de contrôler la fragmentation et les valeurs de durée de vie pour le paquet de message ICMP d’écho.

Send(IPAddress, TimeSpan, Byte[], PingOptions)
Send(String)

Essaie d’envoyer un message ICMP d’écho à l’ordinateur spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur.

Send(String, Int32)

Essaie d’envoyer un message ICMP d’écho à l’ordinateur spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette méthode vous permet de spécifier une valeur de délai d’attente pour l’opération.

Send(String, Int32, Byte[])

Essaie d’envoyer un message ICMP d’écho à l’ordinateur spécifié avec le tampon de données spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

Send(String, Int32, Byte[], PingOptions)

Essaie d’envoyer un message ICMP d’écho à l’ordinateur spécifié avec le tampon de données spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération et de contrôler la fragmentation et les valeurs de durée de vie pour le paquet ICMP.

Send(String, TimeSpan, Byte[], PingOptions)
SendAsync(IPAddress, Int32, Byte[], Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

SendAsync(IPAddress, Int32, Byte[], PingOptions, Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération et de contrôler la fragmentation et les valeurs de durée de vie pour le paquet de message ICMP d’écho.

SendAsync(IPAddress, Int32, Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

SendAsync(IPAddress, Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone à l’ordinateur qui a le IPAddress spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur.

SendAsync(String, Int32, Byte[], Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone à l’ordinateur spécifié avec le tampon de données spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

SendAsync(String, Int32, Byte[], PingOptions, Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone à l’ordinateur spécifié avec le tampon de données spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération et de contrôler la fragmentation et les valeurs de durée de vie pour le paquet ICMP.

SendAsync(String, Int32, Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone à l’ordinateur spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

SendAsync(String, Object)

Essaie d’envoyer un message ICMP d’écho de manière asynchrone à l’ordinateur spécifié et de recevoir un message ICMP de réponse à écho correspondant de cet ordinateur.

SendAsyncCancel()

Annule toutes les demandes asynchrones en attente pour envoyer un message ICMP d’écho et reçoit un message ICMP de réponse à écho correspondant.

SendPingAsync(IPAddress)

Envoie un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone.

SendPingAsync(IPAddress, Int32)

Envoie un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

SendPingAsync(IPAddress, Int32, Byte[])

Envoie un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération et une mémoire tampon à utiliser pour l’envoi et la réception.

SendPingAsync(IPAddress, Int32, Byte[], PingOptions)

Envoie un message ICMP d’écho avec le tampon de données spécifié à l’ordinateur qui a le IPAddress spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération, une mémoire tampon à utiliser pour les envois et les réceptions, et de contrôler la fragmentation et les valeurs de durée de vie pour le paquet de message ICMP d’écho.

SendPingAsync(String)

Envoie un message ICMP d’écho à l’ordinateur spécifié avec le tampon de données spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone.

SendPingAsync(String, Int32)

Envoie un message ICMP d’écho à l’ordinateur spécifié avec le tampon de données spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone. Cette surcharge vous permet de spécifier une valeur de délai pour l’opération.

SendPingAsync(String, Int32, Byte[])

Envoie un message ICMP d’écho à l’ordinateur spécifié avec le tampon de données spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération et une mémoire tampon à utiliser pour l’envoi et la réception.

SendPingAsync(String, Int32, Byte[], PingOptions)

Envoie un message ICMP d’écho à l’ordinateur spécifié avec le tampon de données spécifié et reçoit un message ICMP de réponse à écho correspondant de cet ordinateur en tant qu’opération asynchrone. Cette surcharge vous permet de spécifier une valeur de délai d’attente pour l’opération, une mémoire tampon à utiliser pour les envois et les réceptions, et de contrôler la fragmentation et les valeurs de durée de vie pour le paquet de message ICMP d’écho.

ToString()

Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée.

(Hérité de Component)
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Événements

Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().

(Hérité de Component)
PingCompleted

Se produit quand une opération asynchrone pour envoyer un message ICMP d’écho et recevoir le message ICMP de réponse à écho correspondant se termine ou est annulée.

Implémentations d’interfaces explicites

IDisposable.Dispose()

Libère toutes les ressources utilisées par des instances de la classe Ping.

S’applique à

Voir aussi