Socket.LingerState Propriedade

Definição

Namespace:

System.Net.Sockets

Assembly:

System.Net.Sockets.dll

Assembly:

System.dll

Assembly:

netstandard.dll

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.

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.

Exceções

SocketException

Ocorreu um erro ao tentar acessar o soquete.

ObjectDisposedException

O Socket foi fechado.

Exemplos

O exemplo de código a seguir demonstra o uso da LingerState propriedade.

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 altera a forma como Close o método se comporta. Essa propriedade quando definida modifica as condições sob as quais a conexão pode ser redefinida pelo Winsock. As redefinições de conexão ainda podem ocorrer com base no comportamento do protocolo IP.

Essa propriedade controla o período de tempo em que uma conexão orientada à conexão permanecerá aberta após uma chamada para Close quando os dados permanecerão para serem enviados.

Quando você chama métodos para enviar dados para um par, esses dados são colocados no buffer de rede de saída. Essa propriedade pode ser usada para garantir que esses dados sejam enviados para o host remoto antes que o Close método abandone a conexão.

Para habilitar a permanência, crie uma LingerOption instância que contenha os valores desejados e defina a LingerState propriedade para essa instância.

A tabela a seguir descreve o comportamento do Close método para os valores possíveis da Enabled propriedade e da LingerTime propriedade armazenada na LingerState propriedade.

LingerState.Enabled	LingerState.LingerTime	Comportamento
false (desabilitado), o valor padrão	O tempo limite não é aplicável (padrão).	Tenta enviar dados pendentes até que o tempo limite do protocolo IP padrão expire.
true (habilitado)	Um tempo limite sem zero	Tenta enviar dados pendentes até que o tempo limite especificado expire e, se a tentativa falhar, o Winsock redefinirá a conexão.
true (habilitado)	Um tempo limite zero.	Descarta todos os dados pendentes. Para o TCP (soquete orientado à conexão, por exemplo), o Winsock redefine a conexão.

A pilha de IP calcula 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. Na maioria dos casos, o tempo limite calculado pela pilha é mais relevante do que um definido por um aplicativo. Esse é o comportamento padrão de um soquete quando a LingerState propriedade não está definida.

Quando a LingerTime propriedade armazenada na LingerState propriedade for definida como maior do que o tempo limite de tempo limite do protocolo IP padrão, o tempo limite padrão do protocolo IP ainda será aplicado e substituído.