在将来的某个时间调用单个操作的最佳方式？

Question

我想触发一个计时器在将来的某个时刻执行一次。为了代码简洁，我想使用 lambda 表达式。所以我想做一些类似的事情......

(new System.Threading.Timer(() => { DoSomething(); },
                    null,  // no state required
                    TimeSpan.FromSeconds(x), // Do it in x seconds
                    TimeSpan.FromMilliseconds(-1)); // don't repeat

我认为它非常整洁。但在这种情况下，Timer 对象没有被释放。解决这个问题的最佳方法是什么？或者，我应该在这里采取完全不同的方法吗？

Answer 1

这种方法是有缺陷的。
您正在内存中创建一个没有引用的对象。这意味着计时器对象可被垃圾收集。虽然此代码有时会起作用，但您无法预测垃圾收集何时启动并删除计时器。

例如，在下面的代码中，我强制进行垃圾收集，这会导致计时器永远不会触发。

static void Main(string[] args)
{
    DoThing();
    GC.Collect();
    Thread.Sleep(5000);
}


static void DoThing()
{
    new System.Threading.Timer(x => { Console.WriteLine("Here"); },
            null,  
            TimeSpan.FromSeconds(1), 
            TimeSpan.FromMilliseconds(-1));
}

Answer 2

这将实现你想要的，但我不确定它是最好的解决方案。我认为它简短而优雅，但可能比它的价值更令人困惑和难以理解。

System.Threading.Timer timer = null;
timer = new System.Threading.Timer(
    (object state) => { DoSomething(); timer.Dispose(); }
    , null // no state required
    ,TimeSpan.FromSeconds(x) // Do it in x seconds
    ,TimeSpan.FromMilliseconds(-1)); // don't repeat

Answer 3

不使用计时器，而是利用线程池：

bool fired = false;

ThreadPool.RegisterWaitForSingleObject(new ManualResetEvent(false), 
    (state, triggered) =>
    {
        fired = true;
    }, 
    0, 9000, true);

GC.Collect();

Thread.Sleep(10000);

Assert.IsTrue(fired);

这可以在垃圾回收中幸存下来，因为您不必保留对任何内容的引用。

Answer 4

你可以只包装计时器类......

class Program
{
    static void Main(string[] args)
    {
        MyTimer.Create(
            () => { Console.WriteLine("hello"); },
            5000);
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.Read();
    }
}
public class MyTimer
{
    private MyTimer() { }
    private Timer _timer;
    private ManualResetEvent _mre;

    public static void Create(Action action, int dueTime)
    {
        var timer = new MyTimer();
        timer._mre = new ManualResetEvent(false);

        timer._timer = new Timer(
            (x) =>
            {
                action();
                timer._mre.Set();
            },
            null,
            dueTime,
            Timeout.Infinite
            );

        new Thread(new ThreadStart(() =>
        {
            timer._mre.WaitOne();
            timer._timer.Dispose();
        })).Start();
    }
}

Answer 5

计时器对象可能实现了析构函数。
您可以在文档或反射器中轻松验证这一点。

如果这是真的，你就不用担心。除非这段代码被多次调用，在这种情况下，您应该努力确定计时器的释放，这意味着您将保存一个计时器数组。

Answer 6

如果您有一个 Dispatcher 并且希望处于 UI (Dispatcher) 线程中，请使用此函数：

    void MyNonAsyncFunction()
    {
        Dispatcher.InvokeAsync(async () =>
        {
            await Task.Delay(1000);
            MessageBox.Show("Thank you for waiting");
        });
    }

此函数不是异步的，因为您不想在函数内等待。如果您想在不同时间安排多个事件，则这种方法可能很有用，但也许您确实需要以下方法：

    async void MyAsyncFunction()
    {
        // Do my other things

        await Task.Delay(1000);
        MessageBox.Show("Thank you for waiting");
    }

它执行相同的操作，但要求在函数末尾发生等待。

由于您可能没有调度程序或想要使用它，但仍然想在不同时间安排多个操作，所以我会使用线程：

    static void MyFunction()
    {
        // Do other things...
        Schedule(1000, delegate
        {
            System.Diagnostics.Debug.WriteLine("Thanks for waiting");
        });
    }

    static void Schedule(int delayMs, Action action)
    {
#if DONT_USE_THREADPOOL
        // If use of threadpool is undesired:
        new System.Threading.Thread(async () =>
        {
            await Task.Delay(delayMs);
            action();
        }
        ).Start(); // No need to store the thread object, just fire and forget
#else
        // Using the threadpool:
        Task.Run(async delegate
        {
            await Task.Delay(delayMs);
            action();
        });
#endif
    }

如果您想避免异步，我建议不要使用线程池并替换等待 Task.Delay(delayMs) 调用与 Thread.Sleep(delayMs) 调用

Answer 7

您可以使用 TaskCompletionSource 例如：

static Task<T> ExecuteLater<T>(int delay, Func<T> func)
{
    var tcs = new TaskCompletionSource<T>();

    var timer = new System.Timers.Timer(delay) { AutoReset = false };
    timer.Elapsed += delegate { timer.Dispose(); tcs.SetResult(func()); };
    timer.Start();

    return tcs.Task;
}

并像这样调用它：

var result = await ExecuteLater<int>(5000, () => 50);

---

Or simply call:

 var result = await Task.Delay(5000).ContinueWith<int>((t) => { return 50; });

Answer 8

          System.Reactive.Linq.Observable.Interval(TimeSpan.FromSeconds(1))
            .FirstAsync()
            .Subscribe(_ => DoSomething()));