Socket.LingerState Propriedade

Definição

Obtém ou define um valor que especifica se o Socket atrasará ao fechar um soquete em uma tentativa de enviar todos os dados pendentes.Gets or sets a value that specifies whether the Socket will delay closing a socket in an attempt to send all pending data.

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; }
public System.Net.Sockets.LingerOption LingerState { get; set; }
member this.LingerState : System.Net.Sockets.LingerOption with get, set
Public Property LingerState As LingerOption

Valor da propriedade

LingerOption

Um LingerOption que especifica como perdurar ao fechar um soquete.A LingerOption that specifies how to linger while closing a socket.

Exceções

Ocorreu um erro ao tentar acessar o soquete.An error occurred when attempting to access the socket.

O Socket foi fechado.The Socket has been closed.

Exemplos

O exemplo de código a seguir demonstra o uso da LingerState propriedade.The following code example demonstrates the use of the LingerState property.

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

Comentários

A LingerState propriedade muda a forma Close com que o método se comporta.The LingerState property changes the way Close method behaves. Essa propriedade quando definido modifica as condições sob as quais a conexão pode ser redefinida pelo Winsock.This property when set modifies the conditions under which the connection can be reset by Winsock. As redefinições de conexão ainda podem ocorrer com base no comportamento do protocolo IP.Connection resets can still occur based on the IP protocol behavior.

Essa propriedade controla o período de tempo que uma conexão orientada a conexão permanecerá aberta após uma chamada para Close quando os dados permanecerem para serem enviados.This property controls the length of time that a connection-oriented connection will remain open after a call to Close when data remains to be sent.

Quando você chama métodos para enviar dados a um par, esses dados são colocados no buffer de rede de saída.When you call methods to send data to a peer, this data is placed in the outgoing network buffer. Essa propriedade pode ser usada para garantir que esses dados sejam enviados para o host remoto antes que o Close método descarte a conexão.This property can be used to ensure that this data is sent to the remote host before the Close method drops the connection.

Para habilitar o remanescente, crie uma LingerOption instância que contenha os valores desejados e defina a LingerState propriedade para essa instância.To enable lingering, create a LingerOption instance containing the desired values, and set the LingerState property to this instance.

A tabela a seguir descreve o comportamento do Close método para os valores possíveis da Enabled propriedade e a LingerTime Propriedade armazenada na LingerState propriedade.The following table describes the behavior of the Close method for the possible values of the Enabled property and the LingerTime property stored in the LingerState property.

Persistentestate. habilitadoLingerState.Enabled Persistentestate. PersistentetimeLingerState.LingerTime ComportamentoBehavior
false (desabilitado), o valor padrãofalse (disabled), the default value O tempo limite não é aplicável, (padrão).The time-out is not applicable, (default). Tentativas de envio de dados pendentes até que o tempo limite do protocolo IP padrão expire.Attempts to send pending data until the default IP protocol time-out expires.
true habilitadotrue (enabled) Um tempo limite diferente de zeroA nonzero time-out Tentativas de envio de dados pendentes até o tempo limite especificado expiram e, se a tentativa falhar, o Winsock redefinirá a conexão.Attempts to send pending data until the specified time-out expires, and if the attempt fails, then Winsock resets the connection.
true habilitadotrue (enabled) Um tempo limite zero.A zero timeout. Descarta todos os dados pendentes.Discards any pending data. Para o soquete orientado a conexão (TCP, por exemplo), o Winsock redefine a conexão.For connection-oriented socket (TCP, for example), Winsock resets the connection.

A pilha de IP computa o período de tempo limite do protocolo IP padrão a ser usado com base no tempo de ida e volta da conexão.The IP stack computes the default IP protocol time-out period to use based on the round trip time of the connection. Na maioria dos casos, o tempo limite calculado pela pilha é mais relevante do que um definido por um aplicativo.In most cases, the time-out computed by the stack is more relevant than one defined by an application. Esse é o comportamento padrão para um soquete quando a LingerState propriedade não está definida.This is the default behavior for a socket when the LingerState property is not set.

Quando a LingerTime Propriedade armazenada na LingerState propriedade é definida como maior que o tempo limite do protocolo IP padrão, o tempo limite do protocolo IP padrão ainda será aplicado e substituído.When the LingerTime property stored in the LingerState property is set greater than the default IP protocol time-out, the default IP protocol time-out will still apply and override.

Aplica-se a