Recently, I encountered an asynchronous problem when writing the APIs of Asp.Net Core, and I really felt unexpected after solving it, so I wrote it down and shared it with you, and avoid encountering it later.<\/p>\n
<\/p>\n
Before explaining what is asynchronous, let everyone know what the definition of synchronization is, simply put, a task is done continuously, and the next task will not be done before the previous task is done, as shown in the following figure.<\/p>\n
flowchart LR\nA(TASK A) --> B(TASK B)-->C(TASK C) --> D(TASK D) --> E(TASK E)<\/code><\/pre>\nAs for async, it is possible to have multiple tasks at the same time, and there is no need to wait because the simultaneous tasks have not yet completed, as shown in the following figure.<\/p>\n
flowchart LR\nA(TASK A) --> B(TASK B)\nC(TASK C) --> D(TASK D) --> E(TASK E)\nF(TASK F) --> G(TASK G)<\/code><\/pre>\nSo what programming I happen<\/h2>\n
The problem is that when a highly concurrent request is encountered, the APIs are timed out to respond to the request.
\nAfter some modifications and cross-comparisons, it was found that the synchronized writing API encountered the need to communicate with other APIs, and if it was high concurrency, it would cause our APIs to no longer respond.
\nThen there is the fact that when the asynchronous writing is wrong, it will also cause a serious timeout condition, so I will explain it further.<\/p>\n
Asp.Net Core Asynchronous<\/h3>\n
After the .Net Framework 4.5<\/code> there is more async<\/code> and await<\/code> keyword, just declare async<\/code> before you want to pass back the value as an asynchronous method and with Task<T><\/code> to complete the asynchronous method, then use await<\/code> before calling the method to synchronously wait for the result, and do not add the await<\/code> keyword if you do not need to wait. The complete example is as follows.<\/p>\n public async Task<IEnumerable<string>> GetStringAsync()\n {\n await Task.Delay(TimeSpan.FromSeconds(10));\n return new string[]{"First", "Second", "Third"};\n }<\/code><\/pre>\nProblem I have<\/h3>\n
If you write before from the .Net Framework 4.5<\/code>, and need the synchronous syntax to high concurrency requests or complex operations or communicate with other APIs. Then the synchronous API cannot use the await<\/code> keyword when calling to the asynchronous syntax, so it can only use the Task.Result<\/code> method to call, as shown in the following figure.<\/p>\n [HttpGet("Result")]\n public IEnumerable<string> GetResult()\n {\n return _service.GetStringAsync().Result;\n }<\/code><\/pre>\nHowever, the synchronous syntax encounters a high concurrency request will cause a response timeout situation, so the asynchronous syntax will be used to rewrite, but simply adding async<\/code> and work with Task.Result<\/code> will still cause a blocking situation, which is crawling to see MSDN asynchronous programming<\/a> to know that there is such a result, so the following writing method will still cause the request to block the situation.<\/p>\n [HttpGet("Result")]\n public async Task<IEnumerable<string>> GetResult()\n {\n return _service.GetStringAsync().Result;\n }<\/code><\/pre>\nSo how to write is the right way to write?<\/p>\n
Correct writing<\/h3>\n
So in summary, to write an asynchronous API, you basically need to use the keyword async<\/code> first, and then use the return value of Task<T><\/code> or Task<\/code> for whether there is a callback value or no need return value, as shown below.<\/p>\n [HttpGet("String")]\n public async Task<IEnumerable<string>> GetString()\n {\n await Task.Delay(TimeSpan.FromSeconds(10));\n return new string[]{"First", "Second", "Third"};\n }<\/code><\/pre>\nIn addition, when encountering a method that needs to be blocked, that is, when encountering a method that needs to wait for the result of another method, use the keyword await<\/code>, as shown below,<\/p>\n [HttpGet("Result")]\n public async Task<IEnumerable<string>> GetResult()\n {\n return await _service.GetStringAsync();\n }<\/code><\/pre>\nBe careful not to use a way of writing Task.Result<\/code> here, otherwise the reaction time of the run will be greatly reduced.<\/p>\nResult<\/h3>\n
Whether it’s written synchronously or in the asynchronous API call Task.Result<\/code>, the result when a highly concurrent call of 100 times per second is encountered will react with a delay of more than five seconds, and only the async\/await<\/code> can react normally within three seconds.<\/p>\nConclusion<\/h2>\n
After this experience, when writing APIs, first write async<\/code>, so as to avoid the dilemma that the api’s reaction is blocked when high concurrency is blocked. Then the asynchronous’ writing method must be written with aync<\/code> and await<\/code>, avoiding the writing of Task.Result<\/code>, so as to avoid the occurrence of blocking.<\/p>\nReference<\/h2>\n