这种做法是有缺陷的。
您正在内存中创建一个对象，但没有对其进行引用。这意味着计时器对象可用于垃圾回收。虽然此代码在某些时候可以工作，但您无法预测垃圾回收何时启动并删除计时器。
例如，在下面的代码中，我强制执行垃圾收集，这会导致计时器永远不会触发。

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));
}

这将完成你想要的，但我不确定这是最好的解决方案。我认为这是一个简短和优雅的东西，但可能更令人困惑和难以遵循比它的价值。

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

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

bool fired = false;

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

GC.Collect();

Thread.Sleep(10000);

Assert.IsTrue(fired);

这在垃圾回收中仍然存在，因为您不必保留对任何内容的引用。

你可以 Package 这个计时器类...

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();
    }
}

定时器对象 * 可能 * 实现了一个析构函数。你可以在文档或反射器中很容易地验证这一点。
如果这是真的，你就不用担心，除非这段代码被调用了很多次，在这种情况下，你应该争取确定性地释放定时器，这意味着你会持有一个定时器数组。

如果您有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");
    }

它做同样的事情，但是需要在函数结束时执行wait。
由于您可能没有Dispatcher或者不想使用它，但仍然希望在不同的时间调度多个操作，因此我将使用一个线程：

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
    }

如果您希望避免异步，我建议不要使用线程池，并将await Task.Delay(delayMs)调用替换为Thread.Sleep(delayMs)调用

例如，可以使用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);

或直接调用：

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

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