Ping Classe

Riferimento

Definizione

Spazio dei nomi:: System.Net.NetworkInformation

Assembly:: System.Net.Ping.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Origine:: Ping.cs

Origine:: Ping.cs

Origine:: Ping.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Consente a un'applicazione di determinare se un computer remoto è accessibile sulla rete.

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

Ereditarietà: Object

MarshalByRefObject

Component
Ping

Ereditarietà: Object
Ping

Implementazioni: IDisposable

Esempio

Nell'esempio di codice seguente viene illustrato l'uso sincrono della Ping classe.

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

open System.Net.NetworkInformation
open System.Text

// args[0] can be an IPaddress or host name.
[<EntryPoint>]
let main args =
    let pingSender = new Ping()

    // Use the default Ttl value which is 128,
    // but change the fragmentation behavior.
    let options = PingOptions()
    options.DontFragment <- true

    // Create a buffer of 32 bytes of data to be transmitted.
    let data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
    let buffer = Encoding.ASCII.GetBytes data
    let timeout = 120
    let reply: PingReply = pingSender.Send(args.[0], timeout, buffer, options)

    match reply.Status with
    | IPStatus.Success ->
        printfn "Address: %O" reply.Address
        printfn "RoundTrip time: %d" reply.RoundtripTime
        printfn "Time to live: %d" reply.Options.Ttl
        printfn "Don't fragment: %b" reply.Options.DontFragment
        printfn "Buffer size: %d" reply.Buffer.Length
        0
    | _ ->
        eprintfn "Error sending ping: %O" reply
        eprintfn "Error was: %O" reply.Status
        1

L'esempio di codice seguente illustra l'uso della Ping classe in modo asincrono.

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

Commenti

Le applicazioni usano la Ping classe per rilevare se un computer remoto è raggiungibile.

La topologia di rete può determinare se Ping è possibile contattare correttamente un host remoto. La presenza e la configurazione di proxy, apparecchiature NAT (Network Address Translation) o firewall possono impedire Ping l'esito positivo. Un esito positivo Ping indica solo che l'host remoto può essere raggiunto nella rete. La presenza di servizi di livello superiore (ad esempio un server Web) nell'host remoto non è garantita.

Questa classe offre funzionalità simili allo strumento della riga di comando Ping.exe. I Send metodi e SendAsync inviano un messaggio di richiesta echo ICMP (Internet Control Message Protocol) a un computer remoto e attendere un messaggio di risposta echo ICMP da tale computer. Per una descrizione dettagliata dei messaggi ICMP, vedere RFC 792, disponibile in https://www.ietf.org.

I tipi seguenti vengono usati con la Ping classe e sono descritti in dettaglio di seguito.

Nome tipo	Descrizione
IPStatus	Definisce i codici di stato che descrivono il risultato di un messaggio di richiesta echo ICMP.
PingOptions	Consente di configurare o recuperare le impostazioni che controllano il numero di volte in cui il pacchetto di richiesta può essere inoltrato () e se può essere frammentato (Ttl DontFragment ).
PingReply	Contiene i risultati di una richiesta echo ICMP.
PingException	Generato se si verifica un errore non recuperabile.
PingCompletedEventArgs	Contiene i dati associati agli PingCompleted eventi, generati quando una SendAsync chiamata viene completata o annullata.
PingCompletedEventHandler	Delegato che fornisce il metodo di callback richiamato quando una SendAsync chiamata viene completata o annullata.

I Send metodi e SendAsync restituiscono la risposta in un PingReply oggetto . La PingReply.Status proprietà restituisce un IPStatus valore per indicare il risultato della richiesta.

Quando si invia la richiesta, è necessario specificare il computer remoto. A tale scopo, è possibile specificare una stringa del nome host, un indirizzo IP in formato stringa o un IPAddress oggetto .

È anche possibile specificare uno dei tipi di informazioni seguenti:

Dati da accompagnare alla richiesta. Specificando buffer è possibile apprendere la quantità di tempo necessaria per un pacchetto di una determinata dimensione per spostarsi da e verso l'host remoto e l'unità di trasmissione massima del percorso di rete. Vedere gli Send overload o SendAsync che accettano un buffer parametro.
Indica se il pacchetto Echo ICMP può essere frammentato in transito. Vedere la DontFragment proprietà e gli Send overload o SendAsync che accettano un options parametro.
Quante volte i nodi di routing, ad esempio router o gateway, possono inoltrare il pacchetto prima che raggiunga il computer di destinazione o venga rimosso. Vedere Ttl e gli Send overload o SendAsync che accettano un options parametro.
Limite di tempo entro il quale deve essere ricevuta la risposta. Vedere gli Send overload o SendAsync che accettano un timeout parametro.

La Ping classe offre sia metodi sincroni che asincroni per l'invio della richiesta. Se l'applicazione deve bloccarsi durante l'attesa di una risposta, usare i Send metodi . Questi metodi sono sincroni. Se l'applicazione non deve bloccarsi, usare i metodi asincroni SendAsync . Una chiamata a SendAsync viene eseguita nel proprio thread allocata automaticamente dal pool di thread. Al termine dell'operazione asincrona, genera l'evento PingCompleted . Le applicazioni usano un PingCompletedEventHandler delegato per specificare il metodo chiamato per PingCompleted gli eventi. È necessario aggiungere un PingCompletedEventHandler delegato all'evento prima di chiamare SendAsync. Il metodo del delegato riceve un PingCompletedEventArgs oggetto che contiene un PingReply oggetto che descrive il risultato della SendAsync chiamata.

Non è possibile usare la stessa istanza della Ping classe per generare più richieste Echo ICMP simultanee. La chiamata Send mentre una SendAsync chiamata è in corso o chiama SendAsync più volte prima che tutte le chiamate precedenti siano state completate causano un oggetto InvalidOperationException.

Costruttori

Ping()

Inizializza una nuova istanza della classe Ping.

Proprietà

CanRaiseEvents	Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Container	Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component)
DesignMode	Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
Events	Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
Site	Ottiene o imposta l'oggetto ISite di Component. (Ereditato da Component)

Metodi

CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia le risorse non gestite ed elimina le risorse gestite utilizzate dall'oggetto Ping.
Dispose()	Rilascia tutte le risorse usate da Component. (Ereditato da Component)
Dispose(Boolean)	Rilascia le risorse non gestite usate dall'oggetto Ping ed eventualmente elimina le risorse gestite.
Dispose(Boolean)	Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite. (Ereditato da Component)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetService(Type)	Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OnPingCompleted(PingCompletedEventArgs)	Genera l'evento PingCompleted.
Send(IPAddress)	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) a un computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer.
Send(IPAddress, Int32)	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer. Questo metodo consente di specificare un valore di timeout per l'operazione.
Send(IPAddress, Int32, Byte[])	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer. Questo overload consente di specificare un valore di timeout per l'operazione.
Send(IPAddress, Int32, Byte[], PingOptions)	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer. Questo overload consente di specificare un valore di timeout per l'operazione e di controllare la frammentazione e i valori TTL (Time-to-Live) per il pacchetto del messaggio echo ICMP.
Send(IPAddress, TimeSpan, Byte[], PingOptions)	Tenta di inviare un messaggio echo ICMP (Internet Control Message Protocol) al computer con l'oggetto specificato IPAddresse di ricevere un messaggio di risposta echo ICMP corrispondente da tale computer.
Send(String)	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo.
Send(String, Int32)	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo. Questo metodo consente di specificare un valore di timeout per l'operazione.
Send(String, Int32, Byte[])	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo. Questo overload consente di specificare un valore di timeout per l'operazione.
Send(String, Int32, Byte[], PingOptions)	Esegue un tentativo di invio di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo. Questo overload consente di specificare un valore di timeout per l'operazione e di controllare la frammentazione e i valori TTL (Time-to-Live) per il pacchetto ICMP.
Send(String, TimeSpan, Byte[], PingOptions)	Tenta di inviare un messaggio echo ICMP (Internet Control Message Protocol) al computer specificato e di ricevere un messaggio di risposta echo ICMP corrispondente da tale computer.
SendAsync(IPAddress, Int32, Byte[], Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer. Questo overload consente di specificare un valore di timeout per l'operazione.
SendAsync(IPAddress, Int32, Byte[], PingOptions, Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer. Questo overload consente di specificare un valore di timeout per l'operazione e di controllare la frammentazione e i valori TTL (Time-to-Live) per il pacchetto del messaggio echo ICMP.
SendAsync(IPAddress, Int32, Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) a un computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer. Questo overload consente di specificare un valore di timeout per l'operazione.
SendAsync(IPAddress, Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) a un computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer.
SendAsync(String, Int32, Byte[], Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo. Questo overload consente di specificare un valore di timeout per l'operazione.
SendAsync(String, Int32, Byte[], PingOptions, Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo. Questo overload consente di specificare un valore di timeout per l'operazione e di controllare la frammentazione e i valori TTL (Time-to-Live) per il pacchetto ICMP.
SendAsync(String, Int32, Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo. Questo overload consente di specificare un valore di timeout per l'operazione.
SendAsync(String, Object)	Esegue un tentativo di invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo.
SendAsyncCancel()	Annulla tutte le richieste di invio in modalità asincrona di messaggi echo ICMP (Internet Control Message Protocol) in sospeso e riceve un messaggio di risposta echo ICMP corrispondente.
SendPingAsync(IPAddress)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer come operazione asincrona.
SendPingAsync(IPAddress, Int32)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione.
SendPingAsync(IPAddress, Int32, Byte[])	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione e un buffer da utilizzare per inviare e ricevere.
SendPingAsync(IPAddress, Int32, Byte[], PingOptions)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione, un buffer da utilizzare per inviare, ricevere e controllare la frammentazione e i valori TTL (Time-to-Live) per il pacchetto del messaggio echo ICMP.
SendPingAsync(IPAddress, TimeSpan, Byte[], PingOptions, CancellationToken)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer con il IPAddress specificato e riceve il messaggio di risposta echo ICMP corrispondente da quel computer come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione, un buffer da usare per l'invio e la ricezione, la frammentazione del controllo e i valori time-to-Live e un CancellationToken per il pacchetto di messaggi echo ICMP.
SendPingAsync(String)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo come operazione asincrona.
SendPingAsync(String, Int32)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione.
SendPingAsync(String, Int32, Byte[])	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione e un buffer da utilizzare per inviare e ricevere.
SendPingAsync(String, Int32, Byte[], PingOptions)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato al computer remoto specificato e riceve il messaggio di risposta echo ICMP corrispondente da quest'ultimo come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione, un buffer da utilizzare per inviare, ricevere e controllare la frammentazione e i valori TTL (Time-to-Live) per il pacchetto del messaggio echo ICMP.
SendPingAsync(String, TimeSpan, Byte[], PingOptions, CancellationToken)	Invia un messaggio echo ICMP (Internet Control Message Protocol) con il buffer di dati specificato nel computer specificato e riceve un messaggio di risposta echo ICMP corrispondente da tale computer come operazione asincrona. Questo overload consente di specificare un valore di timeout per l'operazione, un buffer da usare per l'invio e la ricezione, la frammentazione del controllo e i valori time-to-Live e un CancellationToken per il pacchetto di messaggi echo ICMP.
ToString()	Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override. (Ereditato da Component)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Eventi

Disposed	Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component)
PingCompleted	Si verifica quando un'operazione di l'invio in modalità asincrona di un messaggio echo ICMP (Internet Control Message Protocol) e relativa ricezione di un messaggio di risposta echo ICMP viene completata o annullata.

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse utilizzate dalle istanze della classe Ping.

Si applica a

Condividi tramite