C#

Simmerliner wrote:

Ideas?

int lastRow_ = 3;

private async void button1_Click(object sender, EventArgs e)
        {
            listBox.Items.AddRange(new object[] {"Hello", "There", "Code", "Project."});
            var task = Task.Run(() => PerformLengthyTask()).ContinueWith(s => DoSomethingWithBool(s));
        }

        private async Task<bool> PerformLengthyTask()
        {
            Thread.Sleep(5000);
            return true;
        }

private async void button1_Click(object sender, EventArgs e)
        {
            Task<bool> lengthyTask = PerformLengthyTask();
            listBox.Items.AddRange(new object[] {"Hello", "There", "Code", "Project."});
            bool result = await lengthyTask;
            //Do something with result
        }

        private async Task<bool> PerformLengthyTask()
        {
            await Task.Delay(5000);
            return true;
        }
        //or not using Task.Delay
        private async Task<bool> PerformLengthyTask()
        {
            await DelayAsync(5000);
            return true;
        }
        private Task DelayAsync(int delay)
        {
            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
            ThreadPool.QueueUserWorkItem(_ => 
            {
                Thread.Sleep(delay);
                tcs.SetResult(false);
            });
            return tcs.Task;
        }

private void button1_Click(object sender, EventArgs e)
        {
            PerformLengthyTask().ContinueWith(task =>
            {
                bool result = task.Result;
                //Do something with result
            }, TaskScheduler.FromCurrentSynchronizationContext());
            listBox.Items.AddRange(new object[] {"Hello", "There", "Code", "Project."});
        }

        private Task<bool> PerformLengthyTask()
        {
            DelayAsync(5000).ContinueWith(_ => true);
        }

        private Task DelayAsync(int delay)
        {
            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
            ThreadPool.QueueUserWorkItem(_ => 
            {
                Thread.Sleep(delay);
                tcs.SetResult(false);
            });
            return tcs.Task;
        }

private sealed class DelayPromise
{
    private readonly TaskCompletionSource<bool> _taskCompletionSource = new TaskCompletionSource<bool>();
    private readonly Timer _timer;
    
    public DelayPromise(int millisecondsDelay)
    {
        _timer = new Timer(state => ((DelayPromise)state).Complete(), this, millisecondsDelay, Timeout.Infinite);
    }
    
    public Task Task
    {
        get { return _taskCompletionSource.Task; }
    }
    
    private void Complete()
    {
        if (_taskCompletionSource.TrySetResult(true))
        {
            _timer.Dispose();
        }
    }
}
                
public static Task DelayAsync(int millisecondsDelay)
{
    var promise = new DelayPromise(millisecondsDelay);
    return promise.Task;
}

private async void button1_Click(object sender, EventArgs e)
{
    listBox.Items.AddRange(new object[] {"Hello", "There", "Code", "Project."});
    await PerformLengthyTask();
}

private async Task<bool> PerformLengthyTask()
{
    await Task.Delay(5000);
    return true;
}

Richard Deeming wrote:

Task.Delay will return a Task which will be completed in 5 seconds.