This repository's main purpose is to demonstrate the various tools that the .NET ecosystem provides us to write code that can run in parallel. Feel free to contribute. :)

1. Required environment
2. Demo Application
   2.1) Static File server
   2.2) Throttled Downloader library
   2.3) Benchmark tool
3. Instructions for running
   3.1) Benchmark
   3.2) Debug
4. Demonstrated tools
   4.1) Baselines
   4.2) Low level abstractions
   4.3) Mid level abstractions
   4.4) High level abstractions
5. Sample benchmark result
6. .NET Profiling
7. Known missing sample codes

• .NET Core 3.0
• Visual Studio 2019

In order to demonstrate the different capabilities, we need a demo application.
In our case this app will be a throttled parallel downloader. The solution contains three projects:

It is an ASP.NET Core 3.0 web-application which can serve static files for http clients.
It exposes the files under the Resources folder through the /resources route.
Related project: ThrottledParallelism

It is a .NET Core 3.0 library, which is exposing a simple API and several implementations of it.

public interface IGovernedParallelDownloader
{
    Task DownloadThemAllAsync(IEnumerable<Uri> uris, ProcessResult processResult, byte maxThreads);
}

Related project: LogFileServer

It is a .NET Core 3.0 console application, which is used to perform micro-benchmarking. It measures execution time, GC cycles, etc.
Related project: RunEverythingInParallel

NOTE

Please note that this demo is I/O bound.
Which means that using techniques like Task.Run or Parallel.XYZ, which are CPU-bound, does not make too much sense, because they are limited to the number of cores in the machine.
So, please scrutinize the provided examples with this in mind.

1. Make sure that Program.cs of the RunEverythingInParallel project look like this:

using System;
using System.Threading;
using BenchmarkDotNet.Running; //BenchmarkRunner

namespace RunEverythingInParallel
{
    class Program
    {
        //Use Release 
        static void Main(string[] args)
        {
            Thread.Sleep(1000); //Wait for the WebApp to start
            BenchmarkRunner.Run<ThrottledDownloader>(); //Add as many benchmarks as you want to run
            Console.ReadLine();
        }
    }
}

2. Build the solution in Release mode (Set the Optimize node in the csproj to true if it is needed)
3. Hit Ctrl+F5 in Visual Studio
4. If you want to run it without VS (by using the dotnet cli) then run the LogFileServer project prior the RunEverythingInParallel

1. Make sure that Program.cs of the RunEverythingInParallel project look like this:

using System;
using System.Threading;
using ThrottledParallelism.Strategies;

namespace RunEverythingInParallel
{
    class Program
    {
        //Use Debug
        static void Main(string[] args)
        {
            Thread.Sleep(1000); //Wait for the WebApp to start
            var downloader = new ThrottledDownloader();
            downloader.Setup();
            downloader.RunExperiment<HighLevel_Foreach_AsParallel>(); 
        }
    }
}

2. Build the solution in Debug mode (Set the Optimize node in the csproj to false if it is needed)
3. Hit F5 in Visual Studio
4. Analyze the choosen code by using the Parallel Watch, Parallel Stack and Tasks windows

BenchmarkDotNet=v0.11.5
OS=Windows 10.0.17134.1069 (1803/April2018Update/Redstone4)
Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores Frequency=2062501 Hz, Resolution=484.8482 ns .NET Core SDK=3.0.100
Host : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
IterationCount=3 RunStrategy=ColdStart

If you want to deep dive into the execution details, I highly recommend you to use some profiling.
If sampling is enough for you, then I encourage you to use CodeTrack

If tracing is needed, then you can play with the Concurrency Visualizer step-by-step

• Reactive eXtensions
• ideas are more than welcome