mattwarren · June 28, 2016 10:47 · danielmarbach · Jun 28, 2016
diff --git a/ContinueWithAllocations.cs b/ContinueWithAllocations.cs
    [Config(typeof(Config))]
    public class ContinueWithAllocations
    {
        private class Config : ManualConfig
        {
            public Config()
            {
                Add(new MemoryDiagnoser());
            }
        }

        [Params(100, 200, 500)]
        public int NumberOfTasks { get; set; }

        private ConcurrentDictionary<Task, Task> tasks;

        [Setup]
        public void SetUp()
        {
            tasks = new ConcurrentDictionary<Task, Task>();
        }

        [Benchmark]
        public Task ContinueWithClojureCapture()
        {
            for (int i = 0; i < NumberOfTasks; i++)
            {
                var runningTask = Task.Delay(1);
                tasks.TryAdd(runningTask, runningTask);
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                runningTask.ContinueWith(t =>
                {
                    Task toBeRemoved;
                    tasks.TryRemove(t, out toBeRemoved);
                }, TaskContinuationOptions.ExecuteSynchronously);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            }

            return Task.WhenAll(tasks.Values);
        }

        [Benchmark]
        public Task ContinueWithWithoutClojureCapture()
        {
            for (int i = 0; i < NumberOfTasks; i++)
            {
                var runningTask = Task.Delay(1);
                tasks.TryAdd(runningTask, runningTask);
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                runningTask.ContinueWith((t, state) =>
                {
                    var runningTasks = (ConcurrentDictionary<Task, Task>) state;
                    Task toBeRemoved;
                    runningTasks.TryRemove(t, out toBeRemoved);
                }, tasks, TaskContinuationOptions.ExecuteSynchronously);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            }

            return Task.WhenAll(tasks.Values);
        }
    }
diff --git a/Results.Home.md b/Results.Home.md
	[Config(typeof(Config))]
	public class ContinueWithAllocations
	{
	private class Config : ManualConfig
	{
	public Config()
	{
	Add(new MemoryDiagnoser());
	}
	}

	[Params(100, 200, 500)]
	public int NumberOfTasks { get; set; }

	private ConcurrentDictionary<Task, Task> tasks;

	[Setup]
	public void SetUp()
	{
	tasks = new ConcurrentDictionary<Task, Task>();
	}

	[Benchmark]
	public Task ContinueWithClojureCapture()
	{
	for (int i = 0; i < NumberOfTasks; i++)
	{
	var runningTask = Task.Delay(1);
	tasks.TryAdd(runningTask, runningTask);
	#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
	runningTask.ContinueWith(t =>
	{
	Task toBeRemoved;
	tasks.TryRemove(t, out toBeRemoved);
	}, TaskContinuationOptions.ExecuteSynchronously);
	#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
	}

	return Task.WhenAll(tasks.Values);
	}

	[Benchmark]
	public Task ContinueWithWithoutClojureCapture()
	{
	for (int i = 0; i < NumberOfTasks; i++)
	{
	var runningTask = Task.Delay(1);
	tasks.TryAdd(runningTask, runningTask);
	#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
	runningTask.ContinueWith((t, state) =>
	{
	var runningTasks = (ConcurrentDictionary<Task, Task>) state;
	Task toBeRemoved;
	runningTasks.TryRemove(t, out toBeRemoved);
	}, tasks, TaskContinuationOptions.ExecuteSynchronously);
	#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
	}

	return Task.WhenAll(tasks.Values);
	}
	}