Socket.LingerState Vlastnost

Definice

Obor názvů:

System.Net.Sockets

Sestavení:

System.Net.Sockets.dll

Zdroj:

Socket.cs

Získá nebo nastaví hodnotu, která určuje, zda Socket bude zpoždění uzavření soketu při pokusu o odeslání všech čekajících dat.

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

Hodnota vlastnosti

LingerOption

Určuje LingerOption , jak zůstat při zavírání soketu.

Výjimky

SocketException

Při pokusu o přístup k soketu došlo k chybě.

ObjectDisposedException

Byla Socket uzavřena.

Příklady

Následující příklad kódu ukazuje použití LingerState vlastnosti .

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

Poznámky

Vlastnost LingerState mění způsob Close chování metody. Tato vlastnost při nastavení upraví podmínky, za kterých může rozhraní Winsock resetovat připojení. K resetování připojení může stále docházet na základě chování protokolu IP.

Tato vlastnost řídí dobu, po kterou připojení orientované připojení zůstane otevřené po volání, Close když data budou ještě odeslána.

Při volání metod pro odeslání dat do partnerského vztahu jsou tato data umístěna do odchozí síťové vyrovnávací paměti. Tato vlastnost se dá použít k zajištění, aby se tato data odeslala na vzdáleného hostitele předtím, než Close metoda přeruší připojení.

Chcete-li povolit přetrvávání, vytvořte LingerOption instanci obsahující požadované hodnoty a nastavte LingerState vlastnost na tuto instanci.

Následující tabulka popisuje chování Close metody pro možné hodnoty Enabled vlastnosti a vlastnost uložená LingerTimeLingerState ve vlastnosti .

LingerState.Enabled	LingerState.LingerTime	Chování
false (zakázáno), výchozí hodnota	Časový limit se nedá použít (výchozí).	Pokouší se odeslat čekající data, dokud nevyprší platnost výchozího časového limitu protokolu IP.
true (povoleno)	Nenulový časový limit	Pokusí se odeslat čekající data, dokud nevyprší zadaný časový limit, a pokud se pokus nezdaří, winsock resetuje připojení.
true (povoleno)	Vypršení časového limitu nuly	Zahodí všechna čekající data. V případě soketu orientovaného na připojení (například TCP) winsock resetuje připojení.

Zásobník IP adres vypočítá výchozí období časového limitu protokolu IP, které se má použít, na základě doby odezvy připojení. Ve většině případů je časový limit vypočítaný zásobníkem relevantnější než časový limit definovaný aplikací. Toto je výchozí chování soketu, pokud není nastavena LingerState vlastnost.

LingerTime Pokud je vlastnost uložená LingerState ve vlastnosti nastavena na vyšší než výchozí časový limit protokolu IP, bude stále platit výchozí časový limit protokolu IP, který se přepíše.