Ping 类

定义

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

继承

Object

MarshalByRefObject

Component

Ping

继承

Object

Ping

实现

IDisposable

示例

下面的代码示例演示如何同步使用 Ping 类。

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

下面的代码示例演示如何异步使用 Ping 类。

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

注解

应用程序使用该 Ping 类检测远程计算机是否可访问。

网络拓扑可以确定是否可以 Ping 成功联系远程主机。 代理、网络地址转换（NAT）设备或防火墙的存在和配置可能会阻止 Ping 成功。 成功 Ping 表示只能在网络上访问远程主机;无法保证远程主机上存在更高级别的服务（如 Web 服务器）。

此类提供的功能类似于 Ping.exe 命令行工具。 SendAsync和Send方法将 Internet 控制消息协议（ICMP）回显请求消息发送到远程计算机，并等待来自该计算机的 ICMP 回显回复消息。 有关 ICMP 消息的详细说明，请参阅以下位置 https://www.ietf.org提供的 RFC 792。

以下类型与类一起使用 Ping ，下面详细介绍了这些类型。

和SendSendAsync方法在对象PingReply中返回答复。 该 PingReply.Status 属性返回一个 IPStatus 值来指示请求的结果。

发送请求时，必须指定远程计算机。 为此，可以提供主机名字符串、采用字符串格式的 IP 地址或对象 IPAddress 。

还可以指定以下任一类型的信息：

• 要随附请求的数据。 通过 buffer 指定，可以了解特定大小的数据包往返远程主机和网络路径的最大传输单位所需的时间。 （请参阅采用参数的 Send 重 SendAsync 载 buffer 。

• ICMP Echo 数据包是否可以在传输中分段。 （请参阅采用 DontFragment 参数的属性和 Send 或 SendAsync 重载 options 。

• 路由节点（例如路由器或网关）可以在数据包到达目标计算机或丢弃之前转发数据包的次数。 （请参阅Ttl和SendSendAsync采用options参数的重载。

• 必须接收答复的时间限制。 （请参阅采用timeout参数的Send重SendAsync载。

该 Ping 类提供用于发送请求的同步和异步方法。 如果应用程序在等待答复时应阻止，请使用 Send 方法;这些方法是同步的。 如果应用程序不应阻止，请使用异步 SendAsync 方法。 调用在其 SendAsync 自己的线程中执行，该线程是从线程池自动分配的。 异步操作完成后，将引发 PingCompleted 该事件。 应用程序使用 PingCompletedEventHandler 委托来指定为 PingCompleted 事件调用的方法。 在调用SendAsync之前，必须向事件添加PingCompletedEventHandler委托。 委托的方法接收一个 PingCompletedEventArgs 对象，该 PingReply 对象包含描述调用结果 SendAsync 的对象。

不能使用相同的类实例 Ping 生成多个同时 ICMP Echo 请求。 Send在SendAsync调用正在进行或多次调用之前，SendAsync调用之前所有调用都会导致一个InvalidOperationException。

另请参阅

• 如何：Ping 主机
• .NET Framework 中的网络编程
• 网络编程示例
• NetworkInformation