Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Post History

80%

+6 −0

Q&A Is it recommended for ASP.NET Web API actions to always include a CancellationToken?

Note: This is basically a question from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based. I am wondering if my ASP.NET C...

1 answer · posted 4y ago by Alexei‭ · last activity 4y ago by Peter Taylor‭

Question c# asp.net-core software-practices asp.net-core-webapi cancellation-token

#7: Post edited by

Moshi‭ · 2020-09-08T09:12:30Z (about 4 years ago)

Copy Link

Raw

Markdown

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based. 

I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:

```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
    private readonly AppDbContext _dbContext;

    public FooController()
    {
        
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
    {
        // some await to async operation here
    }
}
```

An obvious benefit is that all actions are cancellable, but this requires passing the token everywhere (not sure, but some tools such as R# might automatically detect when this is forgotten and suggest/apply automatically to add the token).

I am more interested in the performance aspect of this (e.g. does it make sense for calls that are known to be short?).

#6: Post edited by

Monica Cellio‭ · 2020-09-07T14:46:56Z (about 4 years ago)
looks like the terminating ``` needs to be on its own line? attempting to move text out of the code block...

Copy Link

Raw

Markdown

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}
An obvious benefit is that all actions are cancellable, but this requires passing the token everywhere (not sure, but some tools such as R# might automatically detect when this is forgotten and suggest/apply automatically to add the token).
I am more interested in the performance aspect of this (e.g. does it make sense for calls that are known to be short?).

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}
```
An obvious benefit is that all actions are cancellable, but this requires passing the token everywhere (not sure, but some tools such as R# might automatically detect when this is forgotten and suggest/apply automatically to add the token).
I am more interested in the performance aspect of this (e.g. does it make sense for calls that are known to be short?).

#5: Post edited by

Alexei‭ · 2020-09-07T13:43:35Z (about 4 years ago)
added more details about the question

Copy Link

Raw

Markdown

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}
An obvious benefit is that all actions are cancellable, but this requires passing the token everywhere (not sure, but some tools such as R# might automatically detect when this is forgotten and suggest/apply automatically to add the token).
I am more interested in the performance aspect of this (e.g. does it make sense for calls that are known to be short?).

#4: Post edited by

Alexei‭ · 2020-09-06T13:49:22Z (about 4 years ago)

Copy Link

Raw

Markdown

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}```

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}

#3: Post edited by

Alexei‭ · 2020-09-06T13:49:01Z (about 4 years ago)

Copy Link

Raw

Markdown

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default) // <<----- should I always do this?
{
// some await to async operation here
}
}```

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default)
{
// some await to async operation here
}
}```

#2: Post edited by

Alexei‭ · 2020-09-06T13:48:46Z (about 4 years ago)
fixed the code

Copy Link

Raw

Markdown

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
~~[ApiController]~~
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default) // <<----- should I always do this?
{
// some await to async operation here
}
}

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based.
I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:
```[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
private readonly AppDbContext _dbContext;
public FooController()
{
}
[HttpGet("{id}")]
public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default) // <<----- should I always do this?
{
// some await to async operation here
}
}```

#1: Initial revision by

Alexei‭ · 2020-09-06T13:43:06Z (about 4 years ago)

Copy Link

Raw

Markdown

Is it recommended for ASP.NET Web API actions to always include a CancellationToken?

Note: This is basically [a question](https://stackoverflow.com/questions/50329618/should-i-always-add-cancellationtoken-to-my-controller-actions?noredirect=1#comment112742019_50329618) from Stack Overflow that was closed for a very long period of time and I fear it might get closed again as primarily opinion based. 

I am wondering if my ASP.NET Core 3.1+ Web API should support cancellation for all its methods or only for those which are particularly long. Example:

[ApiController]
[Route("api/[controller]")]
public class FooController : ControllerBase
{
    private readonly AppDbContext _dbContext;

    public FooController()
    {
        
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<FooModel>> GetAsync(int id, CancellationToken ct = default) // <<----- should I always do this?
    {
        // some await to async operation here
    }
}

c# asp.net-core asp.net-core-webapi cancellation-token

Communities

Post History