Ping Třída

Reference

Definice

Obor názvů:: System.Net.NetworkInformation

Sestavení:: System.Net.Ping.dll

Sestavení:: System.dll

Sestavení:: netstandard.dll

Zdroj:: Ping.cs

Zdroj:: Ping.cs

Zdroj:: Ping.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Umožňuje aplikaci určit, zda je vzdálený počítač přístupný přes síť.

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

Dědičnost: Object

MarshalByRefObject

Component
Ping

Dědičnost: Object
Ping

Implementuje: IDisposable

Příklady

Následující příklad kódu ukazuje použití Ping třídy synchronně.

#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

Následující příklad kódu ukazuje použití Ping třídy asynchronně.

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

Poznámky

Aplikace používají Ping třídu ke zjištění, zda je vzdálený počítač dostupný.

Síťová topologie může určit, jestli Ping se může úspěšně spojit se vzdáleným hostitelem. Přítomnost a konfigurace proxy serverů, zařízení pro překlad adres (NAT) nebo bran firewall můžou bránit Ping úspěšnému dokončení. Úspěch Ping značí pouze to, že vzdálený hostitel je dostupný v síti. Přítomnost služeb vyšší úrovně (například webového serveru) na vzdáleném hostiteli není zaručena.

Tato třída poskytuje funkce podobné nástroji příkazového řádku Ping.exe. Metody Send a SendAsync odesílají zprávu požadavku na odezvu protokolu ICMP (Internet Control Message Protocol) vzdálenému počítači a počkají na odpověď odezvy protokolu ICMP z tohoto počítače. Podrobný popis zpráv ICMP najdete v dokumentu RFC 792, který je k dispozici na adrese https://www.ietf.org.

Následující typy se používají s Ping třídou a jsou podrobně popsány níže.

Název typu	Popis
IPStatus	Definuje stavové kódy, které popisují výsledek zprávy žádosti o odezvu PROTOKOLU ICMP.
PingOptions	Umožňuje nakonfigurovat nebo načíst nastavení, která řídí, kolikrát se paket požadavku může předávat (Ttl) a jestli může být fragmentován (DontFragment ).
PingReply	Obsahuje výsledky žádosti o odezvu PROTOKOLU ICMP.
PingException	Vyvolána, pokud dojde k neopravitelné chybě.
PingCompletedEventArgs	Obsahuje data přidružená k událostem PingCompleted , které jsou vyvolány při SendAsync dokončení nebo zrušení volání.
PingCompletedEventHandler	Delegát, který poskytuje metodu zpětného volání vyvolanou SendAsync při dokončení nebo zrušení volání.

Metody Send a SendAsync vrátí odpověď v objektu PingReply . Vlastnost PingReply.Status vrátí IPStatus hodnotu označující výsledek požadavku.

Při odesílání požadavku je nutné zadat vzdálený počítač. Můžete to provést zadáním řetězce názvu hostitele, IP adresy ve formátu řetězce nebo objektu IPAddress .

Můžete také zadat libovolný z následujících typů informací:

Data, která budou doprovázet žádost. Zadání buffer vám umožní zjistit dobu potřebnou k přenosu paketu určité velikosti na vzdáleného hostitele a z tohoto vzdáleného hostitele a maximální jednotku přenosu síťové cesty. (Viz Send přetížení nebo SendAsync , která přebírají buffer parametr.)
Jestli může být paket ICMP Echo během přenosu fragmentován. (Podívejte se na DontFragment vlastnost a Send přetížení nebo SendAsync , která přebírají options parametr.)
Kolikrát můžou směrovací uzly, jako jsou směrovače nebo brány, předat paket před tím, než se dostane do cílového počítače nebo se zahodí. (Viz Ttl a Send přetížení nebo SendAsync , která přebírají options parametr.)
Časový limit, ve kterém musí být odpověď přijata. (Viz Send přetížení nebo SendAsync , která přebírají timeout parametr.

Třída Ping nabízí synchronní i asynchronní metody pro odeslání požadavku. Pokud by vaše aplikace měla blokovat při čekání na odpověď, použijte Send metody. Tyto metody jsou synchronní. Pokud by vaše aplikace neměla blokovat, použijte asynchronní SendAsync metody. Volání se SendAsync spustí ve vlastním vlákně, které je automaticky přiděleno z fondu vláken. Po dokončení asynchronní operace vyvolá PingCompleted událost. Aplikace používají delegáta PingCompletedEventHandler k určení metody, která je volána pro PingCompleted události. Před voláním PingCompletedEventHandler SendAsyncmusíte k události přidat delegáta . Metoda delegáta přijme PingCompletedEventArgs objekt, který obsahuje PingReply objekt, který popisuje výsledek SendAsync volání.

Stejnou instanci třídy nelze použít k vygenerování více souběžných Ping požadavků ICMP Echo. Volání Send v průběhu SendAsync hovoru nebo SendAsync volání několikrát před dokončením všech předchozích volání způsobí InvalidOperationException.

Konstruktory

Ping()

Inicializuje novou instanci Ping třídy .

Vlastnosti

CanRaiseEvents	Získá hodnotu označující, zda komponenta může vyvolat událost. (Zděděno od Component)
Container	Získá objekt IContainer , který obsahuje Component. (Zděděno od Component)
DesignMode	Získá hodnotu, která označuje, zda je aktuálně v režimu návrhu Component . (Zděděno od Component)
Events	Získá seznam obslužných rutin událostí, které jsou připojeny k tomuto Component. (Zděděno od Component)
Site	Získá nebo nastaví ISite z Component. (Zděděno od Component)

Metody

CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy sloužící ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
Dispose()	Uvolní nespravované prostředky a odstraní spravované prostředky používané nástrojem Ping.
Dispose()	Uvolní všechny prostředky používané nástrojem Component. (Zděděno od Component)
Dispose(Boolean)	Uvolní nespravované prostředky používané objektem Ping a volitelně odstraní spravované prostředky.
Dispose(Boolean)	Uvolní nespravované prostředky používané nástrojem Component a volitelně uvolní spravované prostředky. (Zděděno od Component)
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte aktuální životnost objektu služby, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetService(Type)	Vrátí objekt, který představuje službu poskytovanou objektem Component nebo .Container (Zděděno od Component)
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá životnost objektu služby, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
OnPingCompleted(PingCompletedEventArgs)	PingCompleted Vyvolá událost.
Send(IPAddress)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) počítači, který má zadaný IPAddressparametr , a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače.
Send(IPAddress, Int32)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddress, a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Tato metoda umožňuje zadat hodnotu časového limitu pro operaci.
Send(IPAddress, Int32, Byte[])	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddress, a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
Send(IPAddress, Int32, Byte[], PingOptions)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddress odpověď a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci a řízení fragmentace a hodnoty Time-to-Live pro paket zprávy odezvy ICMP.
Send(IPAddress, TimeSpan, Byte[], PingOptions)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) počítači, který má zadaný IPAddressparametr , a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače.
Send(String)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače.
Send(String, Int32)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Tato metoda umožňuje zadat hodnotu časového limitu pro operaci.
Send(String, Int32, Byte[])	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
Send(String, Int32, Byte[], PingOptions)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci a fragmentaci řízení a hodnoty Time-to-Live paketu ICMP.
Send(String, TimeSpan, Byte[], PingOptions)	Pokusí se odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače.
SendAsync(IPAddress, Int32, Byte[], Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddress, a přijmout odpovídající zprávu odezvy ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
SendAsync(IPAddress, Int32, Byte[], PingOptions, Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddress, a přijmout odpovídající zprávu odezvy ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci a řízení fragmentace a hodnoty Time-to-Live pro paket zprávy odezvy ICMP.
SendAsync(IPAddress, Int32, Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) počítači, který má zadanou IPAddresshodnotu , a přijmout odpovídající zprávu odezvy ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
SendAsync(IPAddress, Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) počítači, který má zadanou IPAddresshodnotu , a přijmout odpovídající zprávu odezvy ICMP z tohoto počítače.
SendAsync(String, Int32, Byte[], Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
SendAsync(String, Int32, Byte[], PingOptions, Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci a fragmentaci řízení a hodnoty Time-to-Live paketu ICMP.
SendAsync(String, Int32, Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
SendAsync(String, Object)	Asynchronně se pokusí odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) do zadaného počítače a přijmout odpovídající zprávu odezvy PROTOKOLU ICMP z tohoto počítače.
SendAsyncCancel()	Zruší všechny čekající asynchronní požadavky na odeslání zprávy odezvy protokolu ICMP (Internet Control Message Protocol) a přijme odpovídající zprávu odezvy protokolu ICMP.
SendPingAsync(IPAddress)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddresshodnotu , a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci.
SendPingAsync(IPAddress, Int32)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddresshodnotu , a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
SendPingAsync(IPAddress, Int32, Byte[])	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do počítače, který má zadanou IPAddresshodnotu , a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu operace a vyrovnávací paměť, která se má použít pro odesílání a přijímání.
SendPingAsync(IPAddress, Int32, Byte[], PingOptions)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí počítači, který má zadanou IPAddresshodnotu , a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci, vyrovnávací paměť, která se má použít pro odesílání a příjem, a řídit fragmentaci a hodnoty Time-to-Live pro paket zprávy odezvy ICMP.
SendPingAsync(IPAddress, TimeSpan, Byte[], PingOptions, CancellationToken)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí počítači, který má zadanou IPAddresshodnotu , a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci, vyrovnávací paměť, která se má použít pro odesílání a příjem, řízení fragmentace a hodnoty Time-to-Live a CancellationToken pro paket echo message ICMP.
SendPingAsync(String)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci.
SendPingAsync(String, Int32)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu operace.
SendPingAsync(String, Int32, Byte[])	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu operace a vyrovnávací paměť, která se má použít pro odesílání a přijímání.
SendPingAsync(String, Int32, Byte[], PingOptions)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci, vyrovnávací paměť, která se má použít pro odesílání a příjem, a řídit fragmentaci a hodnoty Time-to-Live pro paket zprávy odezvy ICMP.
SendPingAsync(String, TimeSpan, Byte[], PingOptions, CancellationToken)	Odešle zprávu odezvy protokolu ICMP (Internet Control Message Protocol) se zadanou datovou vyrovnávací pamětí do zadaného počítače a přijme odpovídající zprávu odezvy ICMP z tohoto počítače jako asynchronní operaci. Toto přetížení umožňuje zadat hodnotu časového limitu pro operaci, vyrovnávací paměť, která se má použít pro odesílání a příjem, řízení fragmentace a hodnoty Time-to-Live a CancellationToken pro paket echo message ICMP.
ToString()	String Vrátí hodnotu obsahující název , Componentpokud existuje. Tato metoda by neměla být přepsána. (Zděděno od Component)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Událost

Disposed	Vyvolá se, když je komponenta uvolněna voláním Dispose() metody . (Zděděno od Component)
PingCompleted	Nastane, když asynchronní operace odeslat zprávu odezvy protokolu ICMP (Internet Control Message Protocol) a přijmout odpovídající odpověď icmp odpověď zprávy nebo je zrušena.

Explicitní implementace rozhraní

IDisposable.Dispose()

Uvolní všechny prostředky používané instancemi Ping třídy .

Platí pro