Although this question may be dated, an innovative approach could involve utilizing

Task.Delay(delay).ContinueWith((task) => { /* Code */ });

.

Comparison of Delay Methods

Alternatively, you can use await Task.Delay(delay);

Building an Async Timeout Function

How to Implement a Timer:

Here is an example of how you can implement a timer in C#:

public void SetTimeout(Action action, int timeout)
{
    var timer = new System.Windows.Forms.Timer();
    timer.Interval = timeout;
    timer.Tick += delegate (object sender, EventArgs args)
    {
        action();
        timer.Stop();
    };
    timer.Start();
}

    This function sets a timeout for an action to be executed after a certain period of time. It creates a new thread that sleeps for the specified amount of time and then invokes the given action.

Here is a suggestion

public class DelayTimer : System.Timers.Timer
{
    public DelayTimer(Action action, double interval)
    {
        this.AutoReset = false;
        this.Interval = interval;
        this.Elapsed += (sender, args) => action();
        this.Start();
    }
}
// Usage example
var delayTimer = new DelayTimer(() => {
    Console.WriteLine("Task executed after delay");
}, 500);
delayTimer.Stop();

When you're working with Task.Delay() and trying to update or set a winforms control, make sure to include

TaskScheduler.FromCurrentSynchronizationContext()

. Otherwise, you'll encounter the dreaded Cross thread operation error.

void SetTimeout(Action action, int milliseconds)
{
    Task.Delay(milliseconds).ContinueWith((task) =>
    {
        action();
    }, TaskScheduler.FromCurrentSynchronizationContext());
}           

SetTimeout(() => {
    myButton.Enabled = true;
}, 3000);  

My approach involves utilizing the syntax features of C# 7.0. There are some differences compared to JavaScript; in JavaScript, when a timeout action is executed, it cannot be cleared.

internal static class JsStyleTimeout
{
    private static readonly ConcurrentDictionary<int, Thread> InnerDic;

    private static int _handle;

    static JsStyleTimeout()
    {
        InnerDic = new ConcurrentDictionary<int, Thread>();
    }

    public static int Set(Action action, int delayMs)
    {
        var handle = Interlocked.Increment(ref _handle);

        var thread = new Thread(new ThreadStart(delegate
        {
            Thread.Sleep(delayMs);
            InnerDic.TryRemove(handle, out var _);
            Task.Factory.StartNew(action);
        }));
        InnerDic.TryAdd(handle, thread);

        thread.Start();
        return handle;
    }

    public static void Clear(int handle)
    {
        if (InnerDic.TryRemove(handle, out var thread))
            thread.Abort();
    }
}

If you want to introduce a delay in your code, you can also use the following:

Delay.Do(3000 /*in ms*/, () => { /* Perform an action */ });

In this case, the Delay.Do method is utilized as shown below:

using System;
using System.Timers;

public class Delay
{
    public static void Do(int after, Action action)
    {
        if (after <= 0 || action == null) return;

        var timer = new Timer { Interval = after, Enabled = false };

        timer.Elapsed += (sender, e) =>
        {
            timer.Stop();
            action.Invoke();
            timer.Dispose();
            GC.SuppressFinalize(timer);
        };

        timer.Start();
    }
}

Note: It is important to remember that when updating a control in the UI thread, you should use Control.Invoke:

Delay.Do(2000, () => { lblOk.Invoke((MethodInvoker)(() => { lblOk.Visible = false; })); });

If you're looking to manage time events in your code, consider creating a static class called Timeman. This class will handle all your timed actions. Create separate packages for each action that begins with a delay and name them TimemanEvent. Below is an example of how to use this concept along with the corresponding source code:

    // Register a timed event
    var id = Timeman.SetTimeout(() => {
       Console.log("Code executed successfully");
    }, 3000);  
    // OR
    var id = Timeman.SetTimeout(MyMethod, 3000);
    // Cancel the event
    Timeman.ClearTimeout(id);



public class Timeman {

    private static readonly ConcurrentDictionary<int, TimemanEvent> InnerDic;

    static Timeman() {
        InnerDic = new ConcurrentDictionary<int, TimemanEvent>();
    }

    /// <summary> Generate Unique Dictionary Id </summary>
    private static int GetUniqueId() {
        // If dict is empty take zero
        if (InnerDic.Keys.Count == 0) return 0;
        // If there is only one, take next
        if (InnerDic.Keys.Count == 1) return InnerDic.Keys.First() + 1;
        // Get all id numbers
        var allKeys = InnerDic.Keys.ToList();
        // Check the missing numbers in order.
        allKeys.Sort();
        var firstNumber = allKeys.First();
        var lastNumber = allKeys.Last();
        var missingNumbers = Enumerable.Range(firstNumber, lastNumber).Except(allKeys);
        // If missing numbers are found, take the first one
        if (missingNumbers.Count() > 0) return missingNumbers.First();
        // Take next
        return lastNumber + 1;
    }

    /// <summary> 
    /// Executes the method after a specified time interval (ms).
    /// <code>
    /// var id = Timeman.SetTimeout(() => {
    ///     Console.log("Code executed successfully");
    /// }, 3000);  
    /// OR
    /// var id = Timeman.SetTimeout(MyMethod, 3000);
    /// </code>
    /// </summary>
    public static int SetTimeout(Action action, int delayMs) {

        var uniqueId = GetUniqueId();
        var te = new TimemanEvent(uniqueId, action, delayMs);
        InnerDic.TryAdd(uniqueId, te);
        te.Start();
        return uniqueId;
    }

    /// <summary> 
    /// Cancels the execution of a timeout before completion.
    /// <code>
    /// Timeman.ClearTimeout(id);
    /// </code>
    /// </summary>
    public static void ClearTimeout(int id) {
        if (InnerDic.TryRemove(id, out var tEvent))
            tEvent?.Dispose();
    }
}
internal class TimemanEvent {

    private readonly Action action;
    private readonly Timer timer;
    private readonly int id;

    public TimemanEvent(int id, Action action, int delayMs) {
        
        this.id = id;
        this.action = action;
        this.timer = new Timer
        {
            Interval = delayMs
        };
        timer.Tick += OnTimerTick;
    }

    private void OnTimerTick(object sender, EventArgs e) {
        
        action();
        Timeman.ClearTimeout(id);
    }

    /// <summary> Stop timer and unregister events </summary>
    internal void Dispose() {

        timer.Tick -= OnTimerTick;
        Stop();
    }

    internal void Start() => timer.Start();

    internal void Stop() => timer.Stop();
}

    Creating a method to set timeout for an action in C#:
    
    public void SetActionTimeout(Action action, int milliseconds)
    {
        Action delayedAction = () =>
        {
            Thread.Sleep(milliseconds);
            action();
        };

        new Thread(() => Invoke(delayedAction)).Start();
    }

If you're looking to enhance your programming skills, consider delving into the world of reactive programming. Take a look at https://github.com/Reactive-Extensions/Rx.NET for Reactive Extensions tailored specifically for .NET and go to http://reactivex.io/ for a comprehensive overview on Reactive programming.

Although I am well-versed in the JavaScript reactive library, I might not be able to provide you with a C# example. However, in JavaScript, implementing this concept involves the following steps:

Rx.Observable.fromEvent(..eventdetails..)
    .debounceTime(300)
    .distinctUntilChanged()
    .subscribe(eventHandler);

By setting up your code in this manner, you can link operators together to effectively transform various events from a source to a subscriber. The basic scenario outlined above reacts to an event, such as a keyUp action, and pauses until there is no new keyUp for 300 milliseconds before invoking the eventHandler function—only if the most recent value (after 300ms) differs from the previously emitted value.