PingOptions Classe

Définition

Espace de noms:

System.Net.NetworkInformation

Assembly:

System.Net.Ping.dll

Source:

PingOptions.cs

Utilisé pour contrôler la manière dont les paquets de données Ping sont transmis.

public ref class PingOptions

public class PingOptions

type PingOptions = class

Public Class PingOptions

Héritage

Object

PingOptions

Exemples

L’exemple de code suivant utilise les Pingclasses et PingOptions pour PingReply envoyer une demande d’écho ICMP à l’hôte spécifié sur la ligne de commande.

#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

Remarques

La PingOptions classe fournit les propriétés et DontFragment pour contrôler la Ttl façon dont les paquets de requête d’écho ICMP (Internet Control Message Protocol) sont transmis.

La Ttl propriété spécifie la durée de vie des paquets envoyés par la Ping classe . Cette valeur indique le nombre de nœuds de routage qui peuvent transférer un Ping paquet avant qu’il ne soit ignoré. La définition de cette option est utile si vous souhaitez tester le nombre de forwards, également appelés tronçons, nécessaires pour envoyer un paquet d’un ordinateur source à un ordinateur de destination.

La DontFragment propriété contrôle si les données envoyées à un hôte distant peuvent être divisées en plusieurs paquets. Cette option est utile si vous souhaitez tester l’unité de transmission maximale (MTU) des routeurs et des passerelles utilisés pour transmettre le paquet.

Les instances de la PingOptions classe sont passées aux Send méthodes et SendAsync et la PingReply classe retourne des instances de PingOptions via la Options propriété .

Pour obtenir la liste des valeurs de propriété initiales d’un instance de PingOptions, consultez le PingOptions constructeur.

Constructeurs

PingOptions()	Initialise une nouvelle instance de la classe PingOptions.
PingOptions(Int32, Boolean)	Initialise une nouvelle instance de la classe PingOptions et définit les valeurs de fragmentation et de durée de vie.

Propriétés

DontFragment	Obtient ou définit une valeur Boolean qui contrôle la fragmentation des données envoyées à l'hôte distant.
Ttl	Obtient ou définit le nombre de nœuds de routage qui peuvent transférer les données Ping avant qu'elles ne soient ignorées.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)