我有一个TcpClient，用于将数据发送到远程计算机上的侦听器。远程计算机有时会打开，有时会关闭。因此，TcpClient将无法经常连接。我希望TcpClient在一秒钟后超时，因此它无法连接到远程计算机时花费太多时间。目前，我将此代码用于TcpClient：
try
{
TcpClient client = new TcpClient("remotehost", this.Port);
client.SendTimeout = 1000;
Byte[] data = System.Text.Encoding.Unicode.GetBytes(this.Message);
NetworkStream stream = client.GetStream();
stream.Write(data, 0, data.Length);
data = new Byte[512];
Int32 bytes = stream.Read(data, 0, data.Length);
this.Response = System.Text.Encoding.Unicode.GetString(data, 0, bytes);
stream.Close();
client.Close();
FireSentEvent(); //Notifies of success
}
catch (Exception ex)
{
FireFailedEvent(ex); //Notifies of failure
}
这对于处理任务非常有效。如果可以，它会发送它，如果它无法连接到远程计算机，则捕获异常。但是，当它无法连接时，抛出异常需要十到十五秒。我需要它在大约一秒钟内超时？我如何更改超时时间？
答案 0 :(得分：76)
您需要使用TcpClient的异步BeginConnect方法，而不是尝试同步连接，这是构造函数的作用。像这样：
var client = new TcpClient();
var result = client.BeginConnect("remotehost", this.Port, null, null);
var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1));
if (!success)
{
throw new Exception("Failed to connect.");
}
// we have connected
client.EndConnect(result);
答案 1 :(得分：65)
从.NET 4.5开始，TcpClient有一个很酷的ConnectAsync方法，我们可以这样使用，所以现在很容易：
var client = new TcpClient();
if (!client.ConnectAsync("remotehost", remotePort).Wait(1000))
{
// connection failure
}
答案 2 :(得分：11)
使用https://stackoverflow.com/a/25684549/3975786的另一种选择：
var timeOut = TimeSpan.FromSeconds(5);
var cancellationCompletionSource = new TaskCompletionSource<bool>();
try
{
using (var cts = new CancellationTokenSource(timeOut))
{
using (var client = new TcpClient())
{
var task = client.ConnectAsync(hostUri, portNumber);
using (cts.Token.Register(() => cancellationCompletionSource.TrySetResult(true)))
{
if (task != await Task.WhenAny(task, cancellationCompletionSource.Task))
{
throw new OperationCanceledException(cts.Token);
}
}
...
}
}
}
catch(OperationCanceledException)
{
...
}
答案 3 :(得分：7)
需要注意的一点是，在超时到期之前，BeginConnect调用可能会失败。如果您尝试本地连接，可能会发生这种情况。这是Jon的代码的修改版本......
var client = new TcpClient();
var result = client.BeginConnect("remotehost", Port, null, null);
result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(1));
if (!client.Connected)
{
throw new Exception("Failed to connect.");
}
// we have connected
client.EndConnect(result);
答案 4 :(得分：7)
上述答案未涵盖如何干净地处理已超时的连接。调用TcpClient.EndConnect，关闭超时后成功的连接，并处理TcpClient。
这可能有点矫枉过正，但这对我有用。
private class State
{
public TcpClient Client { get; set; }
public bool Success { get; set; }
}
public TcpClient Connect(string hostName, int port, int timeout)
{
var client = new TcpClient();
//when the connection completes before the timeout it will cause a race
//we want EndConnect to always treat the connection as successful if it wins
var state = new State { Client = client, Success = true };
IAsyncResult ar = client.BeginConnect(hostName, port, EndConnect, state);
state.Success = ar.AsyncWaitHandle.WaitOne(timeout, false);
if (!state.Success || !client.Connected)
throw new Exception("Failed to connect.");
return client;
}
void EndConnect(IAsyncResult ar)
{
var state = (State)ar.AsyncState;
TcpClient client = state.Client;
try
{
client.EndConnect(ar);
}
catch { }
if (client.Connected && state.Success)
return;
client.Close();
}
答案 5 :(得分：3)
在NetworkStream上设置ReadTimeout或WriteTimeout属性以进行同步读/写。 更新OP的代码：
try
{
TcpClient client = new TcpClient("remotehost", this.Port);
Byte[] data = System.Text.Encoding.Unicode.GetBytes(this.Message);
NetworkStream stream = client.GetStream();
stream.WriteTimeout = 1000; // <------- 1 second timeout
stream.ReadTimeout = 1000; // <------- 1 second timeout
stream.Write(data, 0, data.Length);
data = new Byte[512];
Int32 bytes = stream.Read(data, 0, data.Length);
this.Response = System.Text.Encoding.Unicode.GetString(data, 0, bytes);
stream.Close();
client.Close();
FireSentEvent(); //Notifies of success
}
catch (Exception ex)
{
// Throws IOException on stream read/write timeout
FireFailedEvent(ex); //Notifies of failure
}
答案 6 :(得分：1)
以下是基于mcandal解决方案的代码改进。
为client.ConnectAsync任务生成的任何异常添加了异常捕获（例如：服务器无法访问时出现SocketException）
var timeOut = TimeSpan.FromSeconds(5);
var cancellationCompletionSource = new TaskCompletionSource<bool>();
try
{
using (var cts = new CancellationTokenSource(timeOut))
{
using (var client = new TcpClient())
{
var task = client.ConnectAsync(hostUri, portNumber);
using (cts.Token.Register(() => cancellationCompletionSource.TrySetResult(true)))
{
if (task != await Task.WhenAny(task, cancellationCompletionSource.Task))
{
throw new OperationCanceledException(cts.Token);
}
// throw exception inside 'task' (if any)
if (task.Exception?.InnerException != null)
{
throw task.Exception.InnerException;
}
}
...
}
}
}
catch (OperationCanceledException operationCanceledEx)
{
// connection timeout
...
}
catch (SocketException socketEx)
{
...
}
catch (Exception ex)
{
...
}
答案 7 :(得分：0)
如果使用async＆await并希望使用超时而不阻塞，则mcandal提供的答案中的另一种更简单的方法是在后台线程上执行连接并等待结果。例如：
Task<bool> t = Task.Run(() => client.ConnectAsync(ipAddr, port).Wait(1000));
await t;
if (!t.Result)
{
Console.WriteLine("Connect timed out");
return; // Set/return an error code or throw here.
}
// Successful Connection - if we get to here.
有关更多信息和其他示例，请参见Task.Wait MSDN article。
答案 8 :(得分：0)
如 Simon Mourier 所述，可以将ConnectAsync的TcpClient方法与Task一起使用，并尽快停止操作。
例如：
// ...
client = new TcpClient(); // Initialization of TcpClient
CancellationToken ct = new CancellationToken(); // Required for "*.Task()" method
if (client.ConnectAsync(this.ip, this.port).Wait(1000, ct)) // Connect with timeout as 1 second
{
// ... transfer
if (client != null) {
client.Close(); // Close connection and dipose TcpClient object
Console.WriteLine("Success");
ct.ThrowIfCancellationRequested(); // Stop asynchronous operation after successull connection(...and transfer(in needed))
}
}
else
{
Console.WriteLine("Connetion timed out");
}
// ...