Ping Classe

Referência

Definição

Namespace:: System.Net.NetworkInformation

Assembly:: System.Net.Ping.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Origem:: Ping.cs

Origem:: Ping.cs

Origem:: Ping.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Permite que um aplicativo determine se um computador remoto está acessível na rede.

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

Herança: Object

MarshalByRefObject

Component
Ping

Herança: Object
Ping

Implementações: IDisposable

Exemplos

O exemplo de código a seguir demonstra o uso da Ping classe de forma síncrona.

#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

O exemplo de código a seguir demonstra o uso da Ping classe de forma assíncrona.

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

Comentários

Os aplicativos usam a Ping classe para detectar se um computador remoto é acessível.

A topologia de rede pode determinar se Ping um host remoto pode entrar em contato com êxito. A presença e a configuração de proxies, equipamentos NAT (conversão de endereços de rede) ou firewalls podem impedir Ping o sucesso. Um bem-sucedido Ping indica apenas que o host remoto pode ser alcançado na rede; a presença de serviços de nível superior (como um servidor Web) no host remoto não é garantida.

Essa classe fornece funcionalidade semelhante à ferramenta de linha de comando Ping.exe. Os Send métodos e SendAsync enviam uma mensagem de solicitação de eco ICMP (Protocolo de Mensagem de Controle da Internet) para um computador remoto e aguardam uma mensagem de resposta de eco ICMP desse computador. Para obter uma descrição detalhada das mensagens ICMP, consulte RFC 792, disponível em https://www.ietf.org.

Os tipos a seguir são usados com a Ping classe e são descritos em detalhes abaixo.

Nome do tipo	Descrição
IPStatus	Define status códigos que descrevem o resultado de uma mensagem de solicitação de eco ICMP.
PingOptions	Permite definir ou recuperar as configurações que controlam quantas vezes o pacote de solicitação pode ser encaminhado (Ttl) e se ele pode ser fragmentado (DontFragment ).
PingReply	Contém os resultados de uma solicitação de eco ICMP.
PingException	Gerado se ocorrer um erro irrecuperável.
PingCompletedEventArgs	Contém os dados associados PingCompleted a eventos, que são gerados quando uma SendAsync chamada é concluída ou cancelada.
PingCompletedEventHandler	O delegado que fornece o método de retorno de chamada invocado quando uma SendAsync chamada é concluída ou cancelada.

Os Send métodos e SendAsync retornam a resposta em um PingReply objeto . A PingReply.Status propriedade retorna um IPStatus valor para indicar o resultado da solicitação.

Ao enviar a solicitação, você deve especificar o computador remoto. Você pode fazer isso fornecendo uma cadeia de caracteres de nome de host, um endereço IP no formato de cadeia de caracteres ou um IPAddress objeto .

Você também pode especificar qualquer um dos seguintes tipos de informações:

Dados para acompanhar a solicitação. Especificar buffer permite que você aprenda a quantidade de tempo necessária para um pacote de um tamanho específico viajar de e para o host remoto e a unidade de transmissão máxima do caminho de rede. (Consulte as Send sobrecargas ou SendAsync que levam um buffer parâmetro.)
Se o pacote eco ICMP pode ser fragmentado em trânsito. (Consulte a DontFragment propriedade e as Send sobrecargas ou SendAsync que levam um options parâmetro.)
Quantas vezes os nós de roteamento, como roteadores ou gateways, podem encaminhar o pacote antes que ele chegue ao computador de destino ou seja descartado. (Consulte Ttl e as Send sobrecargas ou SendAsync que levam um options parâmetro.)
O limite de tempo dentro do qual a resposta deve ser recebida. (Consulte as Send sobrecargas ou SendAsync que levam um timeout parâmetro.

A Ping classe oferece métodos síncronos e assíncronos para enviar a solicitação. Se o aplicativo deve ser bloqueado enquanto aguarda uma resposta, use os Send métodos ; esses métodos são síncronos. Se o aplicativo não deve ser bloqueado, use os métodos assíncronos SendAsync . Uma chamada para SendAsync é executada em seu próprio thread que é alocado automaticamente do pool de threads. Quando a operação assíncrona é concluída, ela aciona o PingCompleted evento. Os aplicativos usam um PingCompletedEventHandler delegado para especificar o método que é chamado para PingCompleted eventos. Você deve adicionar um PingCompletedEventHandler delegado ao evento antes de chamar SendAsync. O método do delegado recebe um PingCompletedEventArgs objeto que contém um PingReply objeto que descreve o resultado da SendAsync chamada.

Você não pode usar a mesma instância da Ping classe para gerar várias solicitações simultâneas de Eco ICMP. Chamar Send enquanto uma SendAsync chamada está em andamento ou chamar SendAsync várias vezes antes que todas as chamadas anteriores tenham sido concluídas causa um InvalidOperationException.

Construtores

Ping()

Inicializa uma nova instância da classe Ping.

Propriedades

CanRaiseEvents	Obtém um valor que indica se o componente pode acionar um evento. (Herdado de Component)
Container	Obtém o IContainer que contém o Component. (Herdado de Component)
DesignMode	Obtém um valor que indica se o Component está no modo de design no momento. (Herdado de Component)
Events	Obtém a lista de manipuladores de eventos que estão anexados a este Component. (Herdado de Component)
Site	Obtém ou define o ISite do Component. (Herdado de Component)

Métodos

CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
Dispose()	Libera os recursos não gerenciados e descarta aqueles gerenciados usados pelo Ping.
Dispose()	Libera todos os recursos usados pelo Component. (Herdado de Component)
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo objeto Ping e, opcionalmente, libera os recursos gerenciados.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo Component e opcionalmente libera os recursos gerenciados. (Herdado de Component)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject)
GetService(Type)	Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container. (Herdado de Component)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
OnPingCompleted(PingCompletedEventArgs)	Aciona o evento PingCompleted.
Send(IPAddress)	Tenta enviar uma mensagem de eco do protocolo ICMP para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente desse computador.
Send(IPAddress, Int32)	Tenta enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Esse método permite que você especifique um valor de tempo limite para a operação.
Send(IPAddress, Int32, Byte[])	Tenta enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
Send(IPAddress, Int32, Byte[], PingOptions)	Tenta enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco de ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação e controle valores de fragmentação e vida útil para o pacote de mensagem de eco de ICMP.
Send(IPAddress, TimeSpan, Byte[], PingOptions)	Tenta enviar uma mensagem de eco ICMP (Protocolo de Mensagem de Controle de Internet) para o computador que tem o especificado IPAddresse receber uma mensagem de resposta de eco ICMP correspondente desse computador.
Send(String)	Tenta enviar uma mensagem de eco do protocolo ICMP para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador.
Send(String, Int32)	Tenta enviar uma mensagem de eco do protocolo ICMP para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Esse método permite que você especifique um valor de tempo limite para a operação.
Send(String, Int32, Byte[])	Tenta enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
Send(String, Int32, Byte[], PingOptions)	Tenta enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação e a fragmentação de controle e valores de vida útil do pacote ICMP.
Send(String, TimeSpan, Byte[], PingOptions)	Tenta enviar uma mensagem de eco ICMP (Protocolo de Mensagem de Controle da Internet) para o computador especificado e receber uma mensagem de resposta de eco ICMP correspondente desse computador.
SendAsync(IPAddress, Int32, Byte[], Object)	Tenta de forma assíncrona enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
SendAsync(IPAddress, Int32, Byte[], PingOptions, Object)	Tenta de forma assíncrona enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação e controle valores de fragmentação e vida útil para o pacote de mensagem de eco de ICMP.
SendAsync(IPAddress, Int32, Object)	Tenta enviar assincronamente uma mensagem de eco do protocolo ICMP para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente desse computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
SendAsync(IPAddress, Object)	Tenta enviar assincronamente uma mensagem de eco do protocolo ICMP para o computador que tem o IPAddress especificado e receber uma mensagem de resposta de eco do ICMP correspondente desse computador.
SendAsync(String, Int32, Byte[], Object)	Tenta de forma assíncrona enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
SendAsync(String, Int32, Byte[], PingOptions, Object)	Tenta de forma assíncrona enviar uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação e a fragmentação de controle e valores de vida útil do pacote ICMP.
SendAsync(String, Int32, Object)	Tenta enviar uma mensagem de eco do protocolo ICMP para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador de maneira assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
SendAsync(String, Object)	Tenta enviar uma mensagem de eco do protocolo ICMP para o computador especificado e receber uma mensagem de resposta de eco do ICMP correspondente do computador de maneira assíncrona.
SendAsyncCancel()	Cancela todas as solicitações assíncronas pendentes para enviar uma mensagem de eco do protocolo ICMP e receber uma mensagem de resposta de eco ICMP correspondente.
SendPingAsync(IPAddress)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e recebe uma mensagem de resposta de eco do ICMP correspondente do computador como uma operação assíncrona.
SendPingAsync(IPAddress, Int32)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e recebe uma mensagem de resposta de eco do ICMP correspondente do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
SendPingAsync(IPAddress, Int32, Byte[])	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e recebe uma mensagem de resposta de eco do ICMP correspondente do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação e um buffer a ser usado para enviar e receber.
SendPingAsync(IPAddress, Int32, Byte[], PingOptions)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e recebe uma mensagem de resposta de eco do ICMP correspondente do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação, um buffer a ser usado para enviar e receber e controlar a fragmentação e valores de vida útil para o pacote de mensagens de eco ICMP.
SendPingAsync(IPAddress, TimeSpan, Byte[], PingOptions, CancellationToken)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador que tem o IPAddress especificado e recebe uma mensagem de resposta de eco do ICMP correspondente do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação, um buffer a ser usado para envio e recebimento, fragmentação de controle e valores de vida útil e um CancellationToken para o pacote de mensagem de eco ICMP.
SendPingAsync(String)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e recebe uma mensagem de resposta de eco do ICMP do computador como uma operação assíncrona.
SendPingAsync(String, Int32)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e recebe uma mensagem de resposta de eco do ICMP do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação.
SendPingAsync(String, Int32, Byte[])	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e recebe uma mensagem de resposta de eco do ICMP do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação e um buffer a ser usado para enviar e receber.
SendPingAsync(String, Int32, Byte[], PingOptions)	Envia uma mensagem de eco do protocolo ICMP com o buffer de dados especificado para o computador especificado e recebe uma mensagem de resposta de eco do ICMP do computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação, um buffer a ser usado para enviar e receber e controlar a fragmentação e valores de vida útil para o pacote de mensagens de eco ICMP.
SendPingAsync(String, TimeSpan, Byte[], PingOptions, CancellationToken)	Envia uma mensagem de eco ICMP (Protocolo de Mensagem de Controle de Internet) com o buffer de dados especificado para o computador especificado e recebe uma mensagem de resposta de eco ICMP correspondente desse computador como uma operação assíncrona. Essa sobrecarga permite que você especifique um valor de tempo limite para a operação, um buffer a ser usado para envio e recebimento, fragmentação de controle e valores de vida útil e um CancellationToken para o pacote de mensagem de eco ICMP.
ToString()	Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído. (Herdado de Component)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Eventos

Disposed	Ocorre quando o componente é disposto por uma chamada ao método Dispose(). (Herdado de Component)
PingCompleted	Ocorre quando uma operação assíncrona envia uma mensagem de eco do protocolo ICMP e recebe a mensagem de resposta de eco do protocolo ICMP correspondente concluída ou cancelada.

Implantações explícitas de interface

IDisposable.Dispose()

Libera todos os recursos usados por instâncias da classe Ping.

Aplica-se a

Compartilhar via