How to speed up IronPdf when using async/await

Question

I'm trying to make a piece of code run faster. The code is already using async/await. But it's still slow.

So I tried to alter my foreach to use the new IAsyncEnumerable. However I gained 0 performance from this. And it appears to run the code sequentially. Which surprised me. I thought the await foreach would run each iteration in its own thread.

Here's my attempt at speeding up the code.

var bag = new ConcurrentBag<IronPdf.PdfDocument>(); // probably don't need a ConcurrentBag
var foos = _dbContext.Foos;
await foreach (var fooPdf in GetImagePdfs(foos))
{
    bag.Add(fooPdf);
}

private async IAsyncEnumerable<IronPdf.PdfDocument> GetImagePdfs(IEnumerable<Foo> foos)
{
    foreach (var foo in foos)
    {
        var imagePdf = await GetImagePdf(foo);

        yield return imagePdf;
    }
}

private async Task<IronPdf.PdfDocument> GetImagePdf(Foo foo)
{
    using var imageStream = await _httpService.DownloadAsync(foo.Id);
    var imagePdf = await _pdfService.ImageToPdfAsync(imageStream);

    return imagePdf;
}

using IronPdf;
public class PdfService
{
    // this method is quite slow
    public async Task<PdfDocument> ImageToPdfAsync(Stream imageStream)
    {
        var imageDataURL = Util.ImageToDataUri(Image.FromStream(imageStream));
        var html = $@"<img style=""max-width: 100%; max-height: 70%;"" src=""{imageDataURL}"">";
        using var renderer = new HtmlToPdf(new PdfPrintOptions()
        {
            PaperSize = PdfPrintOptions.PdfPaperSize.A4,
        });
        return await renderer.RenderHtmlAsPdfAsync(html);
    }
}

I also gave Parallel.ForEach a try

Parallel.ForEach(foos, async foo =>
{
    var imagePdf = await GetImagePdf(foo);
    bag.Add(imagePdf);
});

However I keep reading that I shouldn't use async with it, so not sure what to do. Also the IronPdf library crashes when doing it that way.

" And it appears to run the code sequentially" care to share what brings you to that conclusion? — Ian Kemp, Oct 10 '20 at 18:35
I put some log messages in there to print when it would start fetching the `foo.Id` and when it would add it to the bag. The sequence was: start 1, done 1, start 2, done 2, etc — Snæbjørn, Oct 10 '20 at 19:03
Do you have error message/stacktrace when using Parallel.ForEach? — Kalten, Oct 10 '20 at 19:44
`var tasks = _dbContext.Foos.Select(x => GetImagePdfs(x)); await Task.WhenAll(Tasks);` — TheGeneral, Oct 10 '20 at 20:27
@MichaelRandall thanks that works. I expected `await foreach` to work like that, but have apparently misunderstood its use — Snæbjørn, Oct 10 '20 at 21:54
@Kalten I get this error: > Could not write to IronPdf temporary html header / footer file — Snæbjørn, Oct 10 '20 at 21:55
As a side note, and sorry if I sound pedantic, async/await is not directly related with making things run faster. If you have many operations to do and you want to do them faster, the solution is to run them **concurrently**, not **asynchronously**. Switching from sync to async alone will hardly make any difference. Switching from sequential to concurrent will make all the difference in the world. Here is a relevant question: [What is the difference between concurrency, parallelism and asynchronous methods?](https://stackoverflow.com/questions/4844637/) — Theodor Zoulias, Oct 10 '20 at 22:23

score 3 · Accepted Answer · edited Oct 22 '20 at 19:16

The problem with your foreach and await foreach approaches is they are going to execute sequentially (even though they take advantage of the async and await pattern). Essentially, await does exactly that, awaits.

In regards to the Parallel.ForEach your suspicions are correct, it's not suitable for async methods an IO bound workloads. Parallel.ForEach takes an Action delegate and giving an async lambda to an Action actually just creates an async void with the consequence of each task running unobserved (which has several disadvantages).

There are many approaches to take from here, but the simplest is to start each task hot, project them to a collection, and await them all to completion. This way you are letting the IO bound workloads offload (term used loosely) to an IO Completion Port, thus allowing any potential thread to go back to the thread pool to get reused by the Task Scheduler efficiently until the IO work completes.

Assuming there are no shared resources, just project the started tasks to an IEnumerable<Task<PdfDocument>> and use Task.WhenAll

Creates a task that will complete when all of the supplied tasks have completed.

var tasks = _dbContext.Foos.Select(x => GetImagePdfs(x))
var results = await Task.WhenAll(tasks);

In the above scenario, when Select enumerates the async method GetImagePdfs each Task is started hot, the Task Scheduler takes care of scheduling any threads that are needed from the threadpool. As soon as any code awaits an IO job a callback is made with the operating system and the thread goes back to the pool to get reused, so on and so forth. Task.WhenAll waits for all the tasks to complete or fault then returns a collection of each result.

Stephanie · Answer 2 · 2021-10-07T02:27:41.920

Moving to IronPdf 2021.9 or greater significantly improved multithreading support and removed deadlocks in my application.
This impacted Async performance of IronPDF "html to pdf" PDF rendering measurably for my application:

https://www.nuget.org/packages/IronPdf/

// PM> Install-Package IronPdf
using IronPdf;
 
var Renderer = new IronPdf.ChromePdfRenderer();
 
// All IronPdf Rendering methods have Async equivalents
var doc = await Renderer.RenderHtmlAsPdfAsync("<h1>Html with CSS and Images</h1>");

doc.SaveAs("example.pdf");

Code Examples:

https://ironpdf.com/examples/async/. (Async PDF Rendering)
https://ironpdf.com/examples/threading/ (MultiThreaded PDF Rendering)
https://ironpdf.com/examples/parallel/ (Parallel.ForEach PDF Rendering)

This is also related to an existing ticket:

Asynchronous Code Is Not Faster than the Synchronous Version

How to speed up IronPdf when using async/await

2 Answers2