Ping Klas

Definitie

public ref class Ping : System::ComponentModel::Component, IDisposable

public ref class Ping : System::ComponentModel::Component

public class Ping : System.ComponentModel.Component, IDisposable

public class Ping : System.ComponentModel.Component

type Ping = class
    inherit Component
    interface IDisposable

type Ping = class
    inherit Component

Public Class Ping
Inherits Component
Implements IDisposable

Public Class Ping
Inherits Component

Overname

Object

MarshalByRefObject

Component

Ping

Implementeringen

IDisposable

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de Ping klasse synchroon gebruikt.

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

In het volgende codevoorbeeld ziet u hoe u de Ping klasse asynchroon gebruikt.

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

Opmerkingen

Toepassingen gebruiken de Ping klasse om te detecteren of een externe computer bereikbaar is.

Netwerktopologie kan bepalen of Ping er verbinding kan worden gemaakt met een externe host. De aanwezigheid en configuratie van proxy's, NAT-apparatuur (Network Address Translation) of firewalls kunnen voorkomen dat Ping ze slagen. Een geslaagde Ping status geeft alleen aan dat de externe host op het netwerk kan worden bereikt. De aanwezigheid van services op een hoger niveau (zoals een webserver) op de externe host is niet gegarandeerd.

Deze klasse biedt functionaliteit die vergelijkbaar is met het opdrachtregelprogramma Ping.exe. De Send en SendAsync methoden verzenden een ICMP-echoaanvraagbericht (Internet Control Message Protocol) naar een externe computer en wachten op een ICMP-echoantwoordbericht van die computer. Zie RFC 792 voor een gedetailleerde beschrijving van ICMP-berichten, beschikbaar op https://www.ietf.org.

De volgende typen worden gebruikt met de Ping klasse en worden hieronder uitgebreid beschreven.

De Send en SendAsync methoden retourneren het antwoord in een PingReply object. De PingReply.Status eigenschap retourneert een IPStatus waarde om het resultaat van de aanvraag aan te geven.

Wanneer u de aanvraag verzendt, moet u de externe computer opgeven. U kunt dit doen door een hostnaamtekenreeks, een IP-adres in tekenreeksindeling of een IPAddress object op te geven.

U kunt ook een van de volgende typen gegevens opgeven:

• Gegevens die bij de aanvraag horen. buffer Door op te geven kunt u de hoeveelheid tijd leren die nodig is voor een pakket van een bepaalde grootte om naar en van de externe host en de maximale transmissie-eenheid van het netwerkpad te reizen. (Zie de Send of SendAsync overbelastingen die een buffer parameter gebruiken.)

• Of het ICMP Echo-pakket kan worden gefragmenteerd tijdens de overdracht. (Zie de DontFragment eigenschap en de Send of SendAsync overbelastingen die een options parameter nemen.)

• Hoe vaak routeringsknooppunten, zoals routers of gateways, het pakket kunnen doorsturen voordat het de doelcomputer bereikt of wordt verwijderd. (Zie Ttl en de Send of SendAsync overbelastingen die een options parameter gebruiken.)

• De tijdslimiet waarbinnen het antwoord moet worden ontvangen. (Zie de Send of SendAsync overbelastingen die een timeout parameter gebruiken.

De Ping klasse biedt zowel synchrone als asynchrone methoden voor het verzenden van de aanvraag. Als uw toepassing moet blokkeren tijdens het wachten op een antwoord, gebruikt u de Send methoden. Deze methoden zijn synchroon. Als uw toepassing niet mag worden geblokkeerd, gebruikt u de asynchrone SendAsync methoden. Een aanroep om uit te SendAsync voeren in een eigen thread die automatisch wordt toegewezen vanuit de threadgroep. Wanneer de asynchrone bewerking is voltooid, wordt de PingCompleted gebeurtenis gegenereerd. Toepassingen gebruiken een PingCompletedEventHandler gemachtigde om de methode op te geven die wordt aangeroepen voor PingCompleted gebeurtenissen. U moet een PingCompletedEventHandler gemachtigde toevoegen aan de gebeurtenis voordat u aanroept SendAsync. De methode van de gemachtigde ontvangt een PingCompletedEventArgs object dat een PingReply object bevat dat het resultaat van de SendAsync aanroep beschrijft.

U kunt niet hetzelfde exemplaar van de Ping klasse gebruiken om meerdere gelijktijdige ICMP Echo-aanvragen te genereren. Bellen Send terwijl een SendAsync gesprek wordt uitgevoerd of meerdere keren wordt gebeld SendAsync voordat alle vorige oproepen zijn voltooid, veroorzaakt een InvalidOperationException.

Zie ook

• Procedure: Een host pingen
• Netwerkprogrammering in het .NET Framework
• Voorbeelden van netwerkprogrammering
• NetworkInformation