How can I specify a connection-only timeout when executing web requests?

.NET's HttpWebRequest exposes 2 properties for specifying a Timeout for connecting with a remote HTTP Server:

• Timeout - Gets or sets the time-out value in milliseconds for the GetResponse and GetRequestStream methods.
• ReadWriteTimeout - The number of milliseconds before the writing or reading times out. The default value is 300,000 milliseconds (5 minutes).

The Timeout property is the closest to what you're after, but it does suggest that regardless of the Timeout value the DNS resolution may take up to 15 seconds:

A Domain Name System (DNS) query may take up to 15 seconds to return or time out. If your request contains a host name that requires resolution and you set Timeout to a value less than 15 seconds, it may take 15 seconds or more before a WebException is thrown to indicate a timeout on your request.

One way to prempt a lower timeout than 15s for DNS lookups is to lookup the hostname yourself, but many solutions requires P/Invoke to specify low-level settings.

Specifying timeouts in ServiceStack HTTP Clients

The underlying HttpWebRequest Timeout and ReadWriteTimeout properties can also be specified in ServiceStack's high-level HTTP Clients, i.e. in C# Service Clients with:

var client = new JsonServiceClient(BaseUri) {
    Timeout = TimeSpan.FromSeconds(30)
};

Or using ServiceStack's HTTP Utils with:

var timeoutMs = 30 * 1000;
var response = url.GetStringFromUrl(requestFilter: req => 
    req.Timeout = timeoutMs);

I believe RestSharp does have timeout properties in RestClient.

        var request = new RestRequest();
        var client = new RestClient
        {
            Timeout = timeout, //Timeout in milliseconds to use for requests made by this client instance
            ReadWriteTimeout = readWriteTimeout //The number of milliseconds before the writing or reading times out.
        };

        var response = client.Execute(request);
        //Handle response

You right, you are unable to set this specific timeout. I don't have enough information about how the libraries were built, but for the purpose they are meant to, I believe they fit. Someone wants to do a request and set a timeout for everything.

I suggest you take a different approach. You are trying to do two different things here that HttpRequest do at once:

1. Try to find the host/stabblish a connection;
2. Transfer data;

You could try to separate this in two stages.

1. Use Ping class (check this out) to try to get to your host and set a timeout for it;
2. Use the HttpRequest IF it works for your needs (of timeout,

This process should not slow down everything, since part of resolving names/routes would be done at the first stage. This would not be totally disposable.

There's a drawback on this solution: your remote host must accept pings. Hope this helps.

I used this method to check if the connection can be established. This however doesn't guarantee that the connection can be established by the subsequent call in HttpWebRequest.

private static bool CanConnect(string machine)
{
    using (TcpClient client = new TcpClient())
    {
        if (!client.ConnectAsync(machine, 443).Wait(50)) // Check if we can connect in 50ms
        {
            return false;
        }
    }

    return true;
}

if timeouts does not suits your need - don't use them. you can use a handler which waits for the operation to complete. when you get a response - stop the handler and proceed. that way you will get short time requests when failing and long time requests for large amounts of data.

something like this maybe:

 var handler = new ManualResetEvent(false);

 request = (HttpWebRequest)WebRequest.Create(url)
 {
    // initialize parameters such as method
 }

 request.BeginGetResponse(new AsyncCallback(delegate(IAsyncResult result)
 {
      try
      {
          var request = (HttpWebRequest)result.AsyncState;

          using (var response = (HttpWebResponse)request.EndGetResponse(result))
          {
              using (var stream = response.GetResponseStream())
              {
                  // success 
              }

              response.Close();
          }
      }
      catch (Exception e)
      {
          // fail operations go here
      }
      finally
      {
          handler.Set(); // whenever i succeed or fail
      }
 }), request);

 handler.WaitOne(); // wait for the operation to complete

What about asking for only the header at first, and then the usual resource if it is successful,

webRequest.Method = "HEAD";