JilOutputFormatter: Synchronous operations are disallowed. Call WriteAsync or set AllowSynchronousIO to true instead

Question

I have this formatter in my .NET Core 3.1 project (which I recently upgraded from 2.1):

public class JilOutputFormatter : TextOutputFormatter {


    public JilOutputFormatter() => 
        JilFormatterConfig.AddSupportedHeaders(SupportedMediaTypes, SupportedEncodings);

    public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) {
        using (var writer = new StreamWriter(context.HttpContext.Response.Body)) {
            JSON.Serialize(context.Object, writer, MyOptions);
            writer.Flush();
        }

        return Task.FromResult(true);
    }

}

And I'm adding it to pipeline with this snippet:

services.AddMvcCore(o => {
    o.OutputFormatters.Insert(0, new JilOutputFormatter());
}).AddOthersBlahBlah();

It was working like a charm when the application was on 2.1. But now on 3.1 I'm getting this error:

An unhandled exception occurred while processing the request. InvalidOperationException: Synchronous operations are disallowed. Call WriteAsync or set AllowSynchronousIO to true instead.

I tried to async the write operation, but can't find the method on Jil. Do you have any idea please?

NOTE: I know there are some answers - like this one - that are saying how to AllowSynchronousIO. But I'm interested on how to async write in Jil.

Looks like you can't. Actual writing happens inside `JSON.Serialize`. If Jil itself doesn't use async operations, you can't do anything. You won't even find the word `Task` if you search in the Jil repo. — Panagiotis Kanavos, Dec 16 '19 at 10:47
BTW the reason Jil and other serializers are (supposedly) faster is they are far more limited than JSON.NET. Jil's benchmarks are against JSON 6 when the *current* version is 12. You should run some benchmarks yourself using BenchmarkDotNet to see whether there's a meaningful perf & allocation difference between those 2 serializers *AND* System.Text.JSON. If it is, you have to decide whether it justifies using synchronous IO. — Panagiotis Kanavos, Dec 16 '19 at 10:49
[Search results for the word `Task`](https://github.com/kevin-montrose/Jil/search?q=Task&type=Code) in Jil's repo. Doesn't appear in the code, appears in 4 unrelated tasks — Panagiotis Kanavos, Dec 16 '19 at 10:53

score 2 · Answer 1 · answered Dec 16 '19 at 11:25

You'll have to use the 3.0 alpha versions. Jil doesn't even include the word Task in the source code in the latest stable version, 2.17 (or Github search is having some issues).

Version 3.0 uses Pipelines directly. You can use the SerializeAsync(T, PipeWriter , Encoding, Options, CancellationToken). Maybe you can work with HttpContext.Response.BodyWriter. I haven't tested this though.

Eg :

public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context,
                                                  Encoding selectedEncoding) 
{
    var data=context.Object;
    var writer=contest.Response.BodyWriter;
    await JSON.SerializeAsync(data,writer,selectedEncoding);
}

score 2 · Answer 2 · edited Jan 18 '21 at 11:47

Errors can revolve around ReadAsync, WriteAsync, and FlushAsync with outputs similar to what is listed below.

Synchronous operations are disallowed. Call ReadAsync or set AllowSynchronousIO to true instead.

Synchronous operations are disallowed. Call WriteAsync or set AllowSynchronousIO to true instead.

Synchronous operations are disallowed. Call FlushAsync or set AllowSynchronousIO to true instead.

As a temporary workaround, you can set the value of AllowSynchronousIO in your ConfigureServices method found in your Startup class.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<KestrelServerOptions>(options =>
    {
        options.AllowSynchronousIO = true;
    });

    // If using IIS:
    services.Configure<IISServerOptions>(options =>
    {
        options.AllowSynchronousIO = true;
    });

    // other services
}

It isn’t a great workaround, but it will keep you moving forward. The better solution is to upgrade your libraries and perform all your actions asynchronously.

See the detailed post .NET Core 3.0 AllowSynchronousIO Workaround by Khalid Abuhakmeh

Does anyone have any recommendations on how to determine where synchronous actions are taking place? They seem to be hidden in layers of dependencies, etc. — ajw170, Dec 13 '22 at 21:29

score 0 · Answer 3 · answered Feb 27 '22 at 19:21

TLDR: As of Dotnet Core 5.0, the default web-server (Kestral) is designed to perform only Async Level work to be the most performant. Enable Sync within Kestral.

Rational: Due to to the majority of software being more IO Dependent than CPU Dependent, Async Programming allows for the system to perform other work, while waiting for the IO to complete (IE; Writing to Disk, Reading something from the network).

Place this within Startup.cs within the ConfigurationService function.

   services.Configure<KestrelServerOptions>(options =>
            {
                options.AllowSynchronousIO = true;
            });

JilOutputFormatter: Synchronous operations are disallowed. Call WriteAsync or set AllowSynchronousIO to true instead

3 Answers3