通用尝试并在C＃中使用超时重试？

Question

我正在寻找一个通用的尝试，并在C＃中使用超时重试。 基本上，我想要以下内容：

bool stopTrying = false;
DateTime time = DateTime.Now;
while (!stopTrying)
{
    try
    {
        //[Statement to Execute]
    }
    catch (Exception ex)
    {
        if (DateTime.Now.Subtract(time).Milliseconds > 10000)
        {
            stopTrying = true;
            throw ex;
        }
    }
}

在上面的例子中，我等待10秒，但它应该是基于参数的变量超时。 我不想在需要使用它的任何地方重复这个完整的代码。 我的代码中有多个地方，它们不是API中内置的超时，如果应用程序尚未准备好执行语句，我将遇到异常。 这也可以避免在这些声明之前对我的应用程序中的延迟进行硬编码。

澄清：有关陈述可能类似于转让。 如果我使用委托和method.Invoke，是不是作用在委托内的调用而不是原始方法？

Answer 1

使用您的示例，解决方案很简单：

bool DoOrTimeout<T>(T method, TimeSpan timeout) where T : delegate // FIXME
{
    bool stopTrying = false;
    DateTime time = DateTime.Now;
    while (!stopTrying)
    {
        try
        {
            method.Invoke();
            stopTrying = true;
        }
        catch (Exception ex)
        {
            if (DateTime.Now.Subtract(time).Milliseconds > timeout.TotalMilliseconds)
            {
                stopTrying = true;
                throw;
            }
        }
    }
}

只需使用委托作为第一个参数调用DoOrTimeout 。

Answer 2

这不是最漂亮的事情，但到目前为止我似乎工作得很好。 并且它不使用异常来指示超时。

public static class TimeoutOperation
{
  private static readonly TimeSpan DefaultTimeout = new TimeSpan(0, 0, 10);
  private static readonly TimeSpan DefaultGranularity = new TimeSpan(0, 0, 0, 0, 100);

  public static ThreadResult<TResult> DoWithTimeout<TResult>(Func<TResult> action)
  {
    return DoWithTimeout<TResult>(action, DefaultTimeout);
  }

  public static ThreadResult<TResult> DoWithTimeout<TResult>(Func<TResult> action, TimeSpan timeout)
  {
    return DoWithTimeout<TResult>(action, timeout, DefaultGranularity);
  }

  public static ThreadResult<TResult> DoWithTimeout<TResult>(Func<TResult> action, TimeSpan timeout, TimeSpan granularity)
  {
    Thread thread = BuildThread<TResult>(action);
    Stopwatch stopwatch = Stopwatch.StartNew();
    ThreadResult<TResult> result = new ThreadResult<TResult>();

    thread.Start(result);
    do
    {
      if (thread.Join(granularity) && !result.WasSuccessful)
      {
        thread = BuildThread<TResult>(action);
        thread.Start(result);
      }

    } while (stopwatch.Elapsed < timeout && !result.WasSuccessful);
    stopwatch.Stop();

    if (thread.ThreadState == System.Threading.ThreadState.Running)
      thread.Abort();

    return result;
  }

  private static Thread BuildThread<TResult>(Func<TResult> action)
  {
    return new Thread(p =>
    {
      ThreadResult<TResult> r = p as ThreadResult<TResult>;
      try { r.Result = action(); r.WasSuccessful = true; }
      catch (Exception) { r.WasSuccessful = false; }
    });
  }

  public class ThreadResult<TResult>
  {
    public TResult Result { get; set; }
    public bool WasSuccessful { get; set; }
  }
}

用法

 var result = TimeoutOperation.DoWithTimeout<int>(() => { Thread.Sleep(100); throw new Exception(); }); result.WasSuccessful // = false result.Value // = 0 var result = TimeoutOperation.DoWithTimeout<int>(() => { Thread.Sleep(2000); return 5; }); result.WasSuccessful // = true result.Value // = 5 

Answer 3

看看这个问题。 你要求的只是我想要的用途之一。
实现C＃通用超时

警告：此示例使用Thread.Abort。 请点击我原始问题的链接，在评论中阅读有关该问题的一些警告。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace Something
{
  public static class TimeoutWrapper
  {
    public static void Invoke(TimeSpan timeout, Action action)
    {
      Invoke(timeout, action, null);
    }
    public static void Invoke(TimeSpan timeout, Action action, Action abort)
    {
      Thread threadToKill = null;
      Action wrappedAction = () =>
      {
        threadToKill = Thread.CurrentThread;
        action();
      };

      IAsyncResult result = wrappedAction.BeginInvoke(null, null);
      if (result.AsyncWaitHandle.WaitOne(timeout, true))
      {
        wrappedAction.EndInvoke(result);
      }
      else
      {
        if (threadToKill != null)
        {
          try { threadToKill.Abort(); }
          catch { /* Ignore */ }
        }

        if (abort != null)
          abort();

        throw new TimeoutException();
      }
    }
  }
}

只需在具有适当超时控制的循环中运行它。

DateTime endAt = DateTime.Now.AddMinutes(1);
Timespan timeout = new Timespan( 0, 0, 0, 5);
while( DateTime.Now < endAt )
{
    try
    {
        TimeoutWrapper.Invoke( timeout, () => DoSomething());
        break;
    } 
    catch( TimeoutException ex ) 
    { /* Do something */ }
}

Answer 4

这段代码错了（无限循环）：

if (DateTime.Now.Subtract(time).Milliseconds > 10000)

正确的是：

if (DateTime.Now.Subtract(time).TotalMilliseconds > 10000)

Answer 5

创建一个方法，该方法接受Statement To Execute的lambda表达式和timeout的参数。 在该方法内部执行try / catch块内的lambda表达式，并使用参数进行超时。

Answer 6

这是一个简单的解决方案：

long TIMEOUT = 60000; // 1 minute
long INTERVAL = 1000; // 1 second

System.DateTime startTime = System.DateTime.Now;    

while (check_condition())
{
    System.Threading.Thread.Sleep(INTERVAL);
    long elapsedTime = System.DateTime.Now.Millisecond - startTime.Millisecond;

    if (elapsedTime > TIMEOUT)
    {
        throw new Exception("Timeout exceeded");
    }
}