PingOptions Clase

Definición

Espacio de nombres:

System.Net.NetworkInformation

Ensamblado:

System.Net.Ping.dll

Source:

PingOptions.cs

Se utiliza para controlar el modo en que se transmiten los paquetes de datos Ping.

public ref class PingOptions

public class PingOptions

type PingOptions = class

Public Class PingOptions

Herencia

Object

PingOptions

Ejemplos

En el ejemplo de código siguiente se usan las Pingclases , PingOptions y PingReply para enviar una solicitud de eco ICMP al host especificado en la línea de comandos.

#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

Comentarios

La PingOptions clase proporciona las Ttl propiedades y DontFragment para controlar cómo se transmiten los paquetes de solicitud de eco del Protocolo de mensajes de control de Internet (ICMP).

La Ttl propiedad especifica el período de vida de los paquetes enviados por la Ping clase . Este valor indica el número de nodos de enrutamiento que pueden reenviar un Ping paquete antes de que se descarte. Establecer esta opción es útil si desea probar el número de reenvíos, también conocido como saltos, es necesario enviar un paquete desde un equipo de origen a un equipo de destino.

La DontFragment propiedad controla si los datos enviados a un host remoto se pueden dividir en varios paquetes. Esta opción es útil si desea probar la unidad de transmisión máxima (MTU) de los enrutadores y puertas de enlace que se usan para transmitir el paquete.

Las instancias de la PingOptions clase se pasan a los Send métodos y SendAsync , y la PingReply clase devuelve instancias de a través de PingOptions la Options propiedad .

Para obtener una lista de valores de propiedad iniciales para una instancia de PingOptions, vea el PingOptions constructor .

Constructores

PingOptions()	Inicializa una nueva instancia de la clase PingOptions.
PingOptions(Int32, Boolean)	Inicializa una nueva instancia de la clase PingOptions y establece los valores de período de vida y fragmentación.

Propiedades

DontFragment	Obtiene o establece un valor Boolean que controla la fragmentación de los datos enviados al host remoto.
Ttl	Obtiene o establece el número de nodos de enrutamiento que pueden reenviar los datos Ping antes de que se descarten.

Métodos

Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)