Ping Classe

Definizione

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.

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

Proprietà

Metodi

Eventi

Implementazioni dell'interfaccia esplicita

Si applica a

Vedi anche

• Procedura: Eseguire il ping di un host
• Programmazione di rete in .NET Framework
• Esempi di programmazione di rete
• NetworkInformation