Ping Klasse

Referenz

Definition

Namespace:: System.Net.NetworkInformation

Assembly:: System.Net.Ping.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Quelle:: Ping.cs

Quelle:: Ping.cs

Quelle:: Ping.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ermöglicht es einer Anwendung, zu bestimmen, ob über das Netzwerk auf einen Remotecomputer zugegriffen werden kann.

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

Vererbung: Object

MarshalByRefObject

Component
Ping

Vererbung: Object
Ping

Implementiert: IDisposable

Beispiele

Im folgenden Codebeispiel wird die synchrone Verwendung der Ping -Klasse veranschaulicht.

#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

Im folgenden Codebeispiel wird die asynchrone Verwendung der Ping -Klasse veranschaulicht.

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

Hinweise

Anwendungen verwenden die Ping -Klasse, um zu erkennen, ob ein Remotecomputer erreichbar ist.

Die Netzwerktopologie kann bestimmen, ob Ping ein Remotehost erfolgreich kontaktiert werden kann. Das Vorhandensein und die Konfiguration von Proxys, NAT-Geräten (Network Address Translation) oder Firewalls kann den Erfolg verhindern Ping . Ein erfolgreicher Ping Wert gibt nur an, dass der Remotehost im Netzwerk erreicht werden kann. Das Vorhandensein von Diensten höherer Ebene (z. B. webserver) auf dem Remotehost ist nicht garantiert.

Diese Klasse bietet ähnliche Funktionen wie das befehlszeilentool Ping.exe. Die Send Methoden und SendAsync senden eine ICMP-Echoanforderungsnachricht (Internet Control Message Protocol) an einen Remotecomputer und warten auf eine ICMP-Echoantwortnachricht von diesem Computer. Eine ausführliche Beschreibung der ICMP-Nachrichten finden Sie unter RFC 792.https://www.ietf.org

Die folgenden Typen werden mit der Ping -Klasse verwendet und im Folgenden ausführlich beschrieben.

Typname	Beschreibung
IPStatus	Definiert status Codes, die das Ergebnis einer ICMP-Echoanforderungsnachricht beschreiben.
PingOptions	Ermöglicht ihnen das Konfigurieren oder Abrufen der Einstellungen, die steuern, wie oft das Anforderungspaket weitergeleitet werden kann (Ttl) und ob es fragmentiert werden kann (DontFragment ).
PingReply	Enthält die Ergebnisse einer ICMP-Echoanforderung.
PingException	Wird ausgelöst, wenn ein nicht behebbarer Fehler auftritt.
PingCompletedEventArgs	Enthält die Daten, die Ereignissen zugeordnet PingCompleted sind, die ausgelöst werden, wenn ein SendAsync Aufruf abgeschlossen oder abgebrochen wird.
PingCompletedEventHandler	Der Delegat, der die Rückrufmethode bereitstellt, die aufgerufen wird, wenn ein SendAsync Aufruf abgeschlossen oder abgebrochen wird.

Die Send Methoden und SendAsync geben die Antwort in einem -Objekt zurück PingReply . Die PingReply.Status -Eigenschaft gibt einen IPStatus Wert zurück, der das Ergebnis der Anforderung angibt.

Beim Senden der Anforderung müssen Sie den Remotecomputer angeben. Hierzu können Sie eine Hostnamenzeichenfolge, eine IP-Adresse im Zeichenfolgenformat oder ein IPAddress Objekt angeben.

Sie können auch einen der folgenden Arten von Informationen angeben:

Daten, die der Anforderung beiliegen. Wenn Sie angeben, buffer können Sie ermitteln, wie lange ein Paket einer bestimmten Größe zum und vom Remotehost gelangen kann, und die maximale Übertragungseinheit des Netzwerkpfads. (Sehen Sie sich die Send - oder SendAsync -Überladungen an, für die ein buffer Parameter erforderlich ist.)
Gibt an, ob das ICMP-Echopaket während der Übertragung fragmentiert werden kann. (Sehen Sie sich die DontFragment -Eigenschaft und die Send - oder SendAsync -Überladungen an, die einen options Parameter annehmen.)
Wie oft Routingknoten, z. B. Router oder Gateways, das Paket weiterleiten können, bevor es den Zielcomputer erreicht oder verworfen wird. (Siehe Ttl und die Send SendAsync Oder-Überladungen, die einen options Parameter annehmen.)
Die Frist, innerhalb der die Antwort empfangen werden muss. (Siehe die Send - oder SendAsync -Überladungen, für die ein timeout Parameter verwendet wird.

Die Ping -Klasse bietet sowohl synchrone als auch asynchrone Methoden zum Senden der Anforderung. Wenn Ihre Anwendung während des Wartens auf eine Antwort blockieren soll, verwenden Sie die Send Methoden. Diese Methoden sind synchron. Wenn Ihre Anwendung nicht blockieren soll, verwenden Sie die asynchronen SendAsync Methoden. Ein Aufruf von wird SendAsync in einem eigenen Thread ausgeführt, der automatisch aus dem Threadpool zugeordnet wird. Wenn der asynchrone Vorgang abgeschlossen ist, löst er das PingCompleted -Ereignis aus. Anwendungen verwenden einen PingCompletedEventHandler Delegaten, um die Methode anzugeben, die für PingCompleted Ereignisse aufgerufen wird. Sie müssen dem Ereignis einen PingCompletedEventHandler Delegaten hinzufügen, bevor Sie aufrufen SendAsync. Die Methode des Delegaten empfängt ein PingCompletedEventArgs Objekt, das ein PingReply Objekt enthält, das das Ergebnis des SendAsync Aufrufs beschreibt.

Sie können nicht dieselbe instance der Ping -Klasse verwenden, um mehrere gleichzeitige ICMP-Echoanforderungen zu generieren. Das Aufrufen Send , während ein SendAsync Anruf ausgeführt wird oder mehrmals aufgerufen SendAsync wird, bevor alle vorherigen Aufrufe abgeschlossen wurden, führt zu einem InvalidOperationException.

Konstruktoren

Ping()

Initialisiert eine neue Instanz der Ping-Klasse.

Eigenschaften

CanRaiseEvents	Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component)
Container	Ruft die IContainer ab, die in der Component enthalten ist. (Geerbt von Component)
DesignMode	Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet. (Geerbt von Component)
Events	Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind. (Geerbt von Component)
Site	Ruft den ISite von Component ab oder legt ihn fest. (Geerbt von Component)

Methoden

CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt die vom Ping verwendeten, nicht verwalteten Ressourcen frei und verwirft die verwalteten Ressourcen.
Dispose()	Gibt alle vom Component verwendeten Ressourcen frei. (Geerbt von Component)
Dispose(Boolean)	Gibt die vom Ping-Objekt verwendeten nicht verwalteten Ressourcen und verwirft optional auch die verwalteten Ressourcen.
Dispose(Boolean)	Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Component)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetService(Type)	Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt. (Geerbt von Component)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
OnPingCompleted(PingCompletedEventArgs)	Löst das PingCompleted-Ereignis aus.
Send(IPAddress)	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung an den Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen.
Send(IPAddress, Int32)	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Methode ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
Send(IPAddress, Int32, Byte[])	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
Send(IPAddress, Int32, Byte[], PingOptions)	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang angeben und die Werte für Fragmentierung und Gültigkeitsdauer des ICMP-Echomeldungspakets steuern.
Send(IPAddress, TimeSpan, Byte[], PingOptions)	Versucht, eine ICMP-Echonachricht (Internet Control Message Protocol) an den Computer mit dem angegebenen IPAddresszu senden und eine entsprechende ICMP-Echoantwortnachricht von diesem Computer zu empfangen.
Send(String)	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen.
Send(String, Int32)	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Methode ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
Send(String, Int32, Byte[])	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
Send(String, Int32, Byte[], PingOptions)	Versucht, eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang angeben und die Werte für Fragmentierung und Gültigkeitsdauer des ICMP-Pakets steuern.
Send(String, TimeSpan, Byte[], PingOptions)	Versucht, eine ICMP-Echonachricht (Internet Control Message Protocol) an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortnachricht von diesem Computer zu empfangen.
SendAsync(IPAddress, Int32, Byte[], Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
SendAsync(IPAddress, Int32, Byte[], PingOptions, Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang angeben und die Werte für Fragmentierung und Gültigkeitsdauer des ICMP-Echomeldungspakets steuern.
SendAsync(IPAddress, Int32, Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung an einen Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
SendAsync(IPAddress, Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung an einen Computer mit der angegebenen IPAddress zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen.
SendAsync(String, Int32, Byte[], Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
SendAsync(String, Int32, Byte[], PingOptions, Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang angeben und die Werte für Fragmentierung und Gültigkeitsdauer des ICMP-Pakets steuern.
SendAsync(String, Int32, Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
SendAsync(String, Object)	Versucht, asynchron eine ICMP (Internet Control Message Protocol)-Echomeldung an den angegebenen Computer zu senden und eine entsprechende ICMP-Echoantwortmeldung von diesem Computer zu empfangen.
SendAsyncCancel()	Bricht alle ausstehenden asynchronen Anforderungen zum Senden einer ICMP (Internet Control Message Protocol)-Echomeldung ab und empfängt eine entsprechende ICMP-Echoantwortmeldung.
SendPingAsync(IPAddress)	Senden Sie eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang.
SendPingAsync(IPAddress, Int32)	Senden Sie eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
SendPingAsync(IPAddress, Int32, Byte[])	Senden Sie eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang und einen Puffer für Senden und Empfangen anzugeben.
SendPingAsync(IPAddress, Int32, Byte[], PingOptions)	Sendet eine ICMP-Echomeldung (Internet Control Message Protocol) mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang angeben, einen Puffer zum Senden und Empfangen und die Werte für Fragmentierung und Gültigkeitsdauer des ICMP-Echomeldungspakets steuern.
SendPingAsync(IPAddress, TimeSpan, Byte[], PingOptions, CancellationToken)	Sendet eine ICMP-Echomeldung (Internet Control Message Protocol) mit dem angegebenen Datenpuffer an einen Computer mit der angegebenen IPAddress und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang, einen Puffer zum Senden und Empfangen, die Fragmentierung und Time-to-Live-Werte und einen CancellationToken für das ICMP-Echonachrichtenpaket angeben.
SendPingAsync(String)	Sendet eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang.
SendPingAsync(String, Int32)	Sendet eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang anzugeben.
SendPingAsync(String, Int32, Byte[])	Sendet eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Diese Überladung ermöglicht es Ihnen, einen Timeoutwert für den Vorgang und einen Puffer für Senden und Empfangen anzugeben.
SendPingAsync(String, Int32, Byte[], PingOptions)	Sendet eine ICMP (Internet Control Message Protocol)-Echomeldung mit dem angegebenen Datenpuffer an den angegebenen Computer und empfängt eine entsprechende ICMP-Echoantwortmeldung von diesem Computer als asynchronen Vorgang. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang angeben, einen Puffer zum Senden und Empfangen und die Werte für Fragmentierung und Gültigkeitsdauer des ICMP-Echomeldungspakets steuern.
SendPingAsync(String, TimeSpan, Byte[], PingOptions, CancellationToken)	Sendet eine ICMP-Echonachricht (Internet Control Message Protocol) mit dem angegebenen Datenpuffer an den angegebenen Computer und empfängt eine entsprechende ICMP-Echoantwortnachricht von diesem Computer als asynchronen Vorgang. Mit dieser Überladung können Sie einen Timeoutwert für den Vorgang, einen Puffer zum Senden und Empfangen, die Fragmentierung und Time-to-Live-Werte und einen CancellationToken für das ICMP-Echonachrichtenpaket angeben.
ToString()	Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden. (Geerbt von Component)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Ereignisse

Disposed	Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird. (Geerbt von Component)
PingCompleted	Tritt ein, wenn ein asynchroner Vorgang zum Senden einer ICMP (Internet Control Message Protocol)-Echomeldung und Empfangen einer entsprechenden ICMP-Echoantwortmeldung abgeschlossen oder abgebrochen wird.

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Gibt alle von Instanzen der Ping-Klasse verwendeten Ressourcen frei.

Gilt für:

Teilen über