Блог

Я реализовал API, в котором есть контроллер, у которого есть дерево вызовов, как показано ниже.

 public async Task<Collection<United.Service.Presentation.LoyaltyModel.Program>> GetRewardPrograms(string languageCode)
{
           
                return await _referenceDataDomain.GetRewardPrograms(languageCode).ConfigureAwait(false);
            
          
}
  

     public async Task<Collection<Program>> GetRewardPrograms(string languageCode)
        {
            return  await _referenceDataProvider.GetRewardPrograms(languageCode).ConfigureAwait(false);
        }
  

  public async Task<Collection<Program>> GetRewardPrograms(string languageCode)
        {
           
            if (string.IsNullOrEmpty(languageCode))
            {
                languageCode = _constants.LANGUAGE_CODE_EN_US;
            }
            var rewardProgramsSet = new Collection<Program>();
            var format = CacheKeysDictionary.CacheKeyFormat(CacheKeysDictionary.RewardPrograms);
            var cacheKey = string.Format(format, languageCode);

            var cacheValue = await _cacheUtility.GetCacheItemAsync<Collection<Program>>(cacheKey).ConfigureAwait(false);
            if (cacheValue != null amp;amp; cacheValue.Any())
                return cacheValue;

            if (_commonConfig.UseLoyaltyService())
            {
                try
                {
                    var cslHttpClient = _serviceProvider.GetRequiredService<ICSLServiceProxy>();
                    var queryStringParams = new NameValueCollection() { { "languageCode", languageCode } };

                    var result = await cslHttpClient.GetAsync<NameValueCollection, RewardProgramsReferenceData>(_commonConfig.LoyaltyServiceUrl(),
                                                "ReferenceDataRewardProgram/idType/a", queryStringParams, _commonConfig.TimeOutDefault());

                    if (result != null amp;amp; result.ResponseData != null amp;amp; result.ResponseData.referenceDataRewardProgramList.Count > 0)
                    {
                        foreach (var item in result.ResponseData.referenceDataRewardProgramList)
                        {
                            var program = new Program
                            {
                                ProgramID = item.ProgramID.ToInt32(),
                                Code = item.ProgramCode,
                                Description = item.Description,
                                Language = new Language { LanguageCode = languageCode }
                            };

                            rewardProgramsSet.Add(program);
                        }
                    }
                }
                catch { }
            }

            if (rewardProgramsSet != null amp;amp; rewardProgramsSet.Any())
            {
                await _cacheUtility.SetCacheItemAsync(cacheKey, rewardProgramsSet).ConfigureAwait(false);
            }

            return rewardProgramsSet;
        }
  

Я получил отзыв code review о том, что, поскольку я делаю все методы асинхронными, а второй блок кода не выполняет никаких асинхронных операций, я должен вернуть task вместо использования метода async, поскольку добавление async внутренне превратило бы мой метод в конечный автомат, и это создало бы некоторые проблемы с производительностью, рецензент направил мне эту статью
https://medium.com/@deep_blue_day/long-story-short-async-await-best-practices-in-net-1f39d7d84050 , пожалуйста, кто-нибудь может подсказать мне, есть ли недостаток в вышеупомянутом подходе.

Я получил свой ответ из этой статьи, опубликованной Стефаном https://blog.stephencleary.com/2016/12/eliding-async-await.html , Спасибо Джонатану за предоставление ссылки

следующий абзац из приведенной выше ссылки является ответом на мой вопрос:

Рекомендуемые рекомендации Я предлагаю следовать этим рекомендациям:

Не исключайте по умолчанию. Используйте async и ожидайте естественного, легко читаемого кода. Рассмотрите возможность исключения, когда метод является просто проходом или перегрузкой.

 // Simple passthrough to next layer: elide.
Task<string> PassthroughAsync(int x) => _service.PassthroughAsync(x);

// Simple overloads for a method: elide.
async Task<string> OverloadsAsync(CancellationToken cancellationToken)
{
    ... // Core implementation, using await.
}
Task<string> OverloadsAsync() => OverloadsAsync(CancellationToken.None);

// Non-trivial passthrough: use keywords.
async Task<string> PassthroughAsync(int x)
{
    // Reasoning: GetFirstArgument can throw.
    //  Even if it doesn't throw today, some yahoo can change it tomorrow, and it's not possible for them to know to change *this* method, too.
    return await _service.PassthroughAsync(GetFirstArgument(), x);
}

// Non-trivial overloads for a method: use keywords.
async Task<string> OverloadsAsync()
{
    // Same reasoning as above; GetDefaultCancellationTokenForThisScope can throw.
    return await OverloadsAsync(GetDefaultCancellationTokenForThisScope());
}