Socket.LingerState Proprietà

Definizione

Spazio dei nomi:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Origine:

Socket.cs

Ottiene o imposta un valore che specifica se il Socket ritarderà la chiusura di un socket durante un tentativo di invio di tutti i dati in sospeso.

public:
 property System::Net::Sockets::LingerOption ^ LingerState { System::Net::Sockets::LingerOption ^ get(); void set(System::Net::Sockets::LingerOption ^ value); };

public System.Net.Sockets.LingerOption? LingerState { get; set; }

member this.LingerState : System.Net.Sockets.LingerOption with get, set

Public Property LingerState As LingerOption

Valore della proprietà

LingerOption

LingerOption che specifica la modalità di attivazione del ritardo durante la chiusura di un socket.

Eccezioni

SocketException

Si è verificato un errore durante il tentativo di accesso al socket.

ObjectDisposedException

L'oggetto Socket è stato chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato l'uso della LingerState proprietà .

static void ConfigureTcpSocket(Socket^ tcpSocket)
{
     
    // Don't allow another socket to bind to this port.
    tcpSocket->ExclusiveAddressUse = true;
     
    // The socket will linger for 10 seconds after
    // Socket.Close is called.
    tcpSocket->LingerState = gcnew LingerOption(true, 10);
     
    // Disable the Nagle Algorithm for this tcp socket.
    tcpSocket->NoDelay = true;
     
    // Set the receive buffer size to 8k
    tcpSocket->ReceiveBufferSize = 8192;
     
    // Set the timeout for synchronous receive methods to
    // 1 second (1000 milliseconds.)
    tcpSocket->ReceiveTimeout = 1000;
     
    // Set the send buffer size to 8k.
    tcpSocket->SendBufferSize = 8192;
     
    // Set the timeout for synchronous send methods
    // to 1 second (1000 milliseconds.)
    tcpSocket->SendTimeout = 1000;
     
    // Set the Time To Live (TTL) to 42 router hops.
    tcpSocket->Ttl = 42;
    Console::WriteLine("Tcp Socket configured:");
    Console::WriteLine("  ExclusiveAddressUse {0}", 
        tcpSocket->ExclusiveAddressUse);
    Console::WriteLine("  LingerState {0}, {1}", 
        tcpSocket->LingerState->Enabled,
        tcpSocket->LingerState->LingerTime);
    Console::WriteLine("  NoDelay {0}",
        tcpSocket->NoDelay);
    Console::WriteLine("  ReceiveBufferSize {0}", 
        tcpSocket->ReceiveBufferSize);
    Console::WriteLine("  ReceiveTimeout {0}",
        tcpSocket->ReceiveTimeout);
    Console::WriteLine("  SendBufferSize {0}",
        tcpSocket->SendBufferSize);
    Console::WriteLine("  SendTimeout {0}",
        tcpSocket->SendTimeout);
    Console::WriteLine("  Ttl {0}",
        tcpSocket->Ttl);
    Console::WriteLine("  IsBound {0}",
        tcpSocket->IsBound);
    Console::WriteLine("");
}

static void ConfigureTcpSocket(Socket tcpSocket)
{
    // Don't allow another socket to bind to this port.
    tcpSocket.ExclusiveAddressUse = true;

    // The socket will linger for 10 seconds after
    // Socket.Close is called.
    tcpSocket.LingerState = new LingerOption (true, 10);

    // Disable the Nagle Algorithm for this tcp socket.
    tcpSocket.NoDelay = true;

    // Set the receive buffer size to 8k
    tcpSocket.ReceiveBufferSize = 8192;

    // Set the timeout for synchronous receive methods to
    // 1 second (1000 milliseconds.)
    tcpSocket.ReceiveTimeout = 1000;

    // Set the send buffer size to 8k.
    tcpSocket.SendBufferSize = 8192;

    // Set the timeout for synchronous send methods
    // to 1 second (1000 milliseconds.)
    tcpSocket.SendTimeout = 1000;

    // Set the Time To Live (TTL) to 42 router hops.
    tcpSocket.Ttl = 42;

    Console.WriteLine("Tcp Socket configured:");

    Console.WriteLine($"  ExclusiveAddressUse {tcpSocket.ExclusiveAddressUse}");

    Console.WriteLine($"  LingerState {tcpSocket.LingerState.Enabled}, {tcpSocket.LingerState.LingerTime}");

    Console.WriteLine($"  NoDelay {tcpSocket.NoDelay}");

    Console.WriteLine($"  ReceiveBufferSize {tcpSocket.ReceiveBufferSize}");

    Console.WriteLine($"  ReceiveTimeout {tcpSocket.ReceiveTimeout}");

    Console.WriteLine($"  SendBufferSize {tcpSocket.SendBufferSize}");

    Console.WriteLine($"  SendTimeout {tcpSocket.SendTimeout}");

    Console.WriteLine($"  Ttl {tcpSocket.Ttl}");

    Console.WriteLine($"  IsBound {tcpSocket.IsBound}");

    Console.WriteLine("");
}

Commenti

La LingerState proprietà modifica il comportamento Close del metodo. Questa proprietà quando impostata modifica le condizioni in cui la connessione può essere reimpostata da Winsock. Le reimpostazioni della connessione possono comunque verificarsi in base al comportamento del protocollo IP.

Questa proprietà controlla l'intervallo di tempo durante il quale una connessione orientata alla connessione rimarrà aperta dopo una chiamata a Close quando i dati rimangono da inviare.

Quando si chiamano metodi per inviare dati a un peer, questi dati vengono inseriti nel buffer di rete in uscita. Questa proprietà può essere usata per assicurarsi che questi dati vengano inviati all'host remoto prima che il Close metodo elimina la connessione.

Per abilitare il ritardo, creare un'istanza LingerOption contenente i valori desiderati e impostare la LingerState proprietà su questa istanza.

Nella tabella seguente viene descritto il comportamento del Close metodo per i valori possibili della Enabled proprietà e la LingerTime proprietà archiviata nella LingerState proprietà .

LingerState.Enabled	LingerState.LingerTime	Comportamento
false (disabilitato), il valore predefinito	Il timeout non è applicabile (impostazione predefinita).	Tenta di inviare dati in sospeso fino alla scadenza del timeout predefinito del protocollo IP.
true (abilitato)	Timeout diverso da zero	Tenta di inviare dati in sospeso fino alla scadenza del timeout specificato e, se il tentativo non riesce, Winsock reimposta la connessione.
true (abilitato)	Timeout zero.	Elimina tutti i dati in sospeso. Per il socket orientato alla connessione ,ad esempio TCP, Winsock reimposta la connessione.

Lo stack IP calcola il periodo di timeout del protocollo IP predefinito da usare in base al tempo di round trip della connessione. Nella maggior parte dei casi, il timeout calcolato dallo stack è più rilevante di uno definito da un'applicazione. Questo è il comportamento predefinito per un socket quando la LingerState proprietà non è impostata.

Quando la LingerTime proprietà archiviata nella LingerState proprietà è impostata su un timeout del protocollo IP predefinito, il timeout predefinito del protocollo IP verrà comunque applicato ed eseguito l'override.