Ефективно використовувати async / wait на веб-API ASP.NET

Я намагаюся використовувати async/awaitфункцію ASP.NET у своєму проекті Web API. Я не дуже впевнений, чи вплине це на ефективність роботи мого сервісу Web API. Будь ласка, знайдіть нижче робочий процес та зразок коду з моєї заявки.

Робочий потік:

Застосування інтерфейсу користувача → Кінцева точка (контролер) веб-API → Спосіб виклику в рівні обслуговування Web API → Виклик іншої зовнішньої веб-служби. (Тут ми маємо взаємодії з БД тощо)

Контролер:

public async Task<IHttpActionResult> GetCountries()
{
    var allCountrys = await CountryDataService.ReturnAllCountries();

    if (allCountrys.Success)
    {
        return Ok(allCountrys.Domain);
    }

    return InternalServerError();
}

Службовий шар:

public Task<BackOfficeResponse<List<Country>>> ReturnAllCountries()
{
    var response = _service.Process<List<Country>>(BackOfficeEndpoint.CountryEndpoint, "returnCountries");

    return Task.FromResult(response);
}

Я перевірив вищевказаний код і працює. Але я не впевнений, чи це правильне використання async/await. Будь ласка, поділіться своїми думками.

Я не дуже впевнений, чи вплине це на ефективність мого API.

Майте на увазі, що головна перевага асинхронного коду на стороні сервера - масштабованість . Це не призведе до того, що ваші запити запускаються швидше. У asyncсвоїй статті про asyncASP.NET я висвітлюю кілька міркувань "чи варто використовувати " .

Я думаю, що ваш випадок використання (виклик інших API) добре підходить для асинхронного коду, тільки майте на увазі, що "асинхронний" не означає "швидший". Найкращий підхід - спочатку зробити ваш інтерфейс користувача чуйним та асинхронним; це зробить ваше додаток відчувати себе швидше , навіть якщо це трохи повільніше.

Що стосується коду, це не асинхронно:

public Task<BackOfficeResponse<List<Country>>> ReturnAllCountries()
{
  var response = _service.Process<List<Country>>(BackOfficeEndpoint.CountryEndpoint, "returnCountries");
  return Task.FromResult(response);
}

Вам знадобиться справді асинхронна реалізація, щоб отримати переваги масштабування async:

public async Task<BackOfficeResponse<List<Country>>> ReturnAllCountriesAsync()
{
  return await _service.ProcessAsync<List<Country>>(BackOfficeEndpoint.CountryEndpoint, "returnCountries");
}

Або (якщо ваша логіка у цьому методі насправді є лише переходом):

public Task<BackOfficeResponse<List<Country>>> ReturnAllCountriesAsync()
{
  return _service.ProcessAsync<List<Country>>(BackOfficeEndpoint.CountryEndpoint, "returnCountries");
}

Зауважте, що легше працювати з типу "всередину", ніж "зсередини". Іншими словами, не починайте з дії асинхронного контролера, а потім не примушуйте асинхронні методи низхідного потоку. Натомість визначте природні асинхронні операції (виклик зовнішніх API, запитів до бази даних тощо) та зробіть їх спочатку асинхронними на найнижчому рівні ( Service.ProcessAsync). Потім дозвольте asyncтрюку вгору, зробивши дії вашого контролера асинхронними як останній крок.

І ні в якому разі не слід використовувати Task.Runв цьому сценарії.

Це правильно, але, можливо, не корисно.

Оскільки нічого чекати - немає дзвінків на блокування API, які могли б працювати асинхронно - тоді ви створюєте структури для відстеження асинхронної роботи (яка має накладні витрати), але потім не використовуєте цю можливість.

Наприклад, якщо сервісний рівень виконував операції з DB з Entity Framework, який підтримує асинхронні виклики:

public Task<BackOfficeResponse<List<Country>>> ReturnAllCountries()
{
    using (db = myDBContext.Get()) {
      var list = await db.Countries.Where(condition).ToListAsync();

       return list;
    }
}

Ви дозволите робочій нитці зробити щось інше, поки db запитується (і таким чином зможете обробити інший запит).

Очікування - це те, що потрібно пройти весь шлях вниз: дуже важко вписатись у ретро-систему.

Ви не використовуєте async / чекаєте ефективно, тому що нитка запиту буде заблокована під час виконання синхронного методуReturnAllCountries()

Потік, призначений для обробки запиту, буде простоюче чекати, поки ReturnAllCountries()це працює.

Якщо ви можете реалізувати ReturnAllCountries()асинхронність, ви побачите переваги масштабування. Це пов’язано з тим, що потік може бути відпущений назад до пулу потоків .NET для обробки іншого запиту під час ReturnAllCountries()виконання. Це дозволить вашій службі мати більш високу пропускну здатність, використовуючи нитки більш ефективно.

Я б змінив ваш рівень обслуговування на:

public Task<BackOfficeResponse<List<Country>>> ReturnAllCountries()
{
    return Task.Run(() =>
    {
        return _service.Process<List<Country>>(BackOfficeEndpoint.CountryEndpoint, "returnCountries");
    }      
}

як це у вас є, ви все ще ведете свій _service.Processдзвінок синхронно і отримуєте дуже мало або не отримуєте користі від його очікування.

При такому підході ви перетворюєте потенційно повільний дзвінок у Task, запускаєте його та повертаєте його до очікування. Тепер ви отримаєте користь від очікування Task.