Ping Klass

Definition

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

Arv

Object

MarshalByRefObject

Component

Ping

Arv

Object

Ping

Implementeringar

IDisposable

Exempel

Följande kodexempel visar hur klassen används Ping synkront.

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

Följande kodexempel visar hur du använder Ping klassen asynkront.

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

Kommentarer

Program använder Ping klassen för att identifiera om en fjärrdator kan nås.

Nätverkstopologin kan avgöra om Ping det går att kontakta en fjärrvärd. Förekomsten och konfigurationen av proxyservrar, NAT-utrustning (network address translation) eller brandväggar kan förhindra Ping att det lyckas. En lyckad Ping indikerar bara att fjärrvärden kan nås i nätverket. Förekomsten av tjänster på högre nivå (till exempel en webbserver) på fjärrvärden garanteras inte.

Den här klassen innehåller funktioner som liknar kommandoradsverktyget Ping.exe. Metoderna Send och SendAsync skickar ett ICMP-ekobegärandemeddelande (Internet Control Message Protocol) till en fjärrdator och väntar på ett ICMP-ekosvarsmeddelande från datorn. En detaljerad beskrivning av ICMP-meddelanden finns i RFC 792, tillgänglig på https://www.ietf.org.

Följande typer används med Ping klassen och beskrivs i detalj nedan.

Metoderna Send och SendAsync returnerar svaret i ett PingReply objekt. Egenskapen PingReply.Status returnerar ett IPStatus värde som anger resultatet av begäran.

När du skickar begäran måste du ange fjärrdatorn. Du kan göra detta genom att ange en värdnamnssträng, en IP-adress i strängformat eller ett IPAddress objekt.

Du kan också ange någon av följande typer av information:

• Data som medföljer begäran. Genom att buffer ange kan du lära dig hur lång tid det tar för ett paket av en viss storlek att resa till och från fjärrvärden och den maximala överföringsenheten för nätverkssökvägen. (Se eller SendSendAsync överlagringar som tar en buffer parameter.)

• Om ICMP Echo-paketet kan fragmenteras under överföring. (Se egenskapen DontFragment och Send eller SendAsync överlagringarna som tar en options parameter.)

• Hur många gånger routningsnoder, till exempel routrar eller gatewayer, kan vidarebefordra paketet innan det når måldatorn eller tas bort. (Se Ttl och Send eller SendAsync överlagringar som tar en options parameter.)

• Den tidsfrist inom vilken svaret måste tas emot. (Se eller SendSendAsync överlagringar som tar en timeout parameter.

Klassen Ping erbjuder både synkrona och asynkrona metoder för att skicka begäran. Om programmet ska blockeras i väntan på ett svar använder du Send metoderna. Dessa metoder är synkrona. Om programmet inte ska blockeras använder du de asynkrona SendAsync metoderna. Ett anrop till SendAsync körs i en egen tråd som automatiskt allokeras från trådpoolen. När den asynkrona åtgärden slutförs genereras PingCompleted händelsen. Program använder ett PingCompletedEventHandler ombud för att ange den metod som anropas för PingCompleted händelser. Du måste lägga till ett PingCompletedEventHandler ombud i händelsen innan du anropar SendAsync. Ombudets metod tar emot ett PingCompletedEventArgs objekt som innehåller ett PingReply objekt som beskriver resultatet av anropet SendAsync .

Du kan inte använda samma instans av Ping klassen för att generera flera samtidiga ICMP Echo-begäranden. Att ringa medan ett Send samtal pågår eller anropa SendAsync flera gånger innan alla tidigare samtal har slutförts orsakar en SendAsync.InvalidOperationException

Se även

• Så här gör du: Pinga en värd
• Nätverksprogrammering i .NET Framework
• Exempel på nätverksprogrammering
• NetworkInformation