ServicePoint.ConnectionLeaseTimeout Propriété

Définition

Espace de noms:

System.Net

Assembly:

System.Net.ServicePoint.dll

Source:

ServicePoint.cs

Obtient ou définit le nombre de millisecondes après quoi une connexion active ServicePoint est fermée.

public:
 property int ConnectionLeaseTimeout { int get(); void set(int value); };

public int ConnectionLeaseTimeout { get; set; }

member this.ConnectionLeaseTimeout : int with get, set

Public Property ConnectionLeaseTimeout As Integer

Valeur de propriété

Int32

Un Int32 qui spécifie le nombre de millisecondes qu’une connexion active ServicePoint reste ouverte. La valeur par défaut est -1, ce qui permet à une connexion active ServicePoint de rester connectée indéfiniment. Définissez cette propriété sur 0 pour forcer ServicePoint connexions à fermer après la maintenance d’une demande.

Exceptions

ArgumentOutOfRangeException

La valeur spécifiée pour une opération de jeu est un nombre négatif inférieur à -1.

Exemples

L’exemple de code suivant définit la valeur de cette propriété.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::IO;
using namespace System::Threading;

namespace SystemNetExamples
{
    public ref class ServicePointExample
    {
    public:

        // Pass in the name of the Web page to retrieve.    
        static void PrintResponse(String^ page)
        {

            // Create the request.
            HttpWebRequest^ request;
            Uri^ uri;
            
 

            try
            {
                uri = gcnew Uri(page);
            }
            catch (UriFormatException^ ex) 
            {
                Console::WriteLine(ex->Message);
            }

            request = (HttpWebRequest^) WebRequest::Create(uri); 

            // Get the service point that handles the request's 
            // socket connection.
            ServicePoint^ point = request->ServicePoint;

            // Set the receive buffer size on the underlying socket.
            point->ReceiveBufferSize = 2048;

            // Set the connection lease timeout to infinite.
            point->ConnectionLeaseTimeout = Timeout::Infinite;

            // Send the request.
            HttpWebResponse^ response = 
                (HttpWebResponse^) request->GetResponse();
            Stream^ responseStream = response->GetResponseStream();
            StreamReader^ streamReader = 
                gcnew StreamReader(responseStream);
            try
            {
                // Display the response.
                Console::WriteLine(streamReader->ReadToEnd());
                responseStream->Close();
                response->Close();
            }
            finally
            {
                streamReader->Close();
            }
        }
    };
}

using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace Examples.System.Net
{
    public class ServicePointExample
    {
        // Pass in the name of the Web page to retrieve.
        public static void Main(string[] args)
        {
            string page;
            if (args == null || args.Length == 0 || args[0].Length == 0)
            {
                page = "http://www.contoso.com/default.html";
            }
            else
            {
                page = args[0];
            }
            // Create the request.
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(page);
            // Get the service point that handles the request's socket connection.
            ServicePoint point = request.ServicePoint;
            // Set the receive buffer size on the underlying socket.
            point.ReceiveBufferSize = 2048;
            // Set the connection lease timeout to infinite.
            point.ConnectionLeaseTimeout = Timeout.Infinite;
            // Send the request.
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream responseStream = response.GetResponseStream();
            StreamReader s = new StreamReader(responseStream);
            // Display the response.
            Console.WriteLine(s.ReadToEnd());
            s.Close();
            responseStream.Close();
            response.Close();
        }
    }
}

Imports System.Net
Imports System.Net.Sockets
Imports System.IO
Imports System.Threading

Public Class ServicePointExample

    ' Pass in the name of the Web page to retrieve.
    Public Shared Sub Main(ByVal args() As String)
        Dim page As String
        If args Is Nothing OrElse args.Length = 0 OrElse args(0).Length = 0 Then
            page = "http://www.contoso.com/default.html"
        Else
            page = args(0)
        End If

        Dim request As HttpWebRequest = CType(WebRequest.Create(page), HttpWebRequest)
        ' Get the service point that handles the request's socket connection.
        Dim point As ServicePoint = request.ServicePoint
        ' Set the receive buffer size on the underlying socket.
        point.ReceiveBufferSize = 2048
        ' Set the connection lease timeout to infinite.
        point.ConnectionLeaseTimeout = Timeout.Infinite
        ' Send the request.
        Dim response As HttpWebResponse = CType(request.GetResponse(), HttpWebResponse)
        Dim responseStream As Stream = response.GetResponseStream()
        Dim s As New StreamReader(responseStream)
        ' Display the response.
        Console.WriteLine(s.ReadToEnd())
        responseStream.Close()
        response.Close()
    End Sub
End Class

Remarques

Prudence

WebRequest, HttpWebRequest, ServicePointet WebClient sont obsolètes et vous ne devez pas les utiliser pour le nouveau développement. Utilisez HttpClient à la place.

Vous pouvez utiliser cette propriété pour vous assurer que les connexions actives d’un objet ServicePoint ne restent pas ouvertes indéfiniment. Cette propriété est destinée aux scénarios où les connexions doivent être supprimées et rétablies périodiquement, telles que les scénarios d’équilibrage de charge.

Par défaut, lorsque KeepAlive est true pour une requête, la propriété MaxIdleTime définit le délai d’attente de fermeture des connexions ServicePoint en raison de l’inactivité. Si le ServicePoint a des connexions actives, MaxIdleTime n’a aucun effet et les connexions restent ouvertes indéfiniment.

Lorsque la propriété ConnectionLeaseTimeout est définie sur une valeur autre que -1 et après l’expiration du délai spécifié, une connexion active ServicePoint est fermée après la maintenance d’une demande en définissant KeepAlive sur false dans cette requête.

La définition de cette valeur affecte toutes les connexions gérées par l’objet ServicePoint.

Voir aussi

• KeepAlive
• KeepAlive
• KeepAlive