Neden senkronize etmek yerine zaman uyumsuz WebAPI işlemleri oluşturmalıyım?

Oluşturduğum bir Web API'de aşağıdaki işlemi yapıyorum:

// GET api/<controller>
[HttpGet]
[Route("pharmacies/{pharmacyId}/page/{page}/{filter?}")]
public CartTotalsDTO GetProductsWithHistory(Guid pharmacyId, int page, string filter = null ,[FromUri] bool refresh = false)
{
    return delegateHelper.GetProductsWithHistory(CustomerContext.Current.GetContactById(pharmacyId), refresh);
}

Bu web hizmetine yapılan çağrı bir Jquery Ajax çağrısı aracılığıyla şu şekilde yapılır:

$.ajax({
      url: "/api/products/pharmacies/<%# Farmacia.PrimaryKeyId.Value.ToString() %>/page/" + vm.currentPage() + "/" + filter,
      type: "GET",
      dataType: "json",
      success: function (result) {
          vm.items([]);
          var data = result.Products;
          vm.totalUnits(result.TotalUnits);
      }          
  });

Önceki işlemi bu şekilde uygulayan bazı geliştiriciler gördüm:

// GET api/<controller>
[HttpGet]
[Route("pharmacies/{pharmacyId}/page/{page}/{filter?}")]
public async Task<CartTotalsDTO> GetProductsWithHistory(Guid pharmacyId, int page, string filter = null ,[FromUri] bool refresh = false)
{
    return await Task.Factory.StartNew(() => delegateHelper.GetProductsWithHistory(CustomerContext.Current.GetContactById(pharmacyId), refresh));
}

GetProductsWithHistory () işleminin oldukça uzun bir işlem olduğunu söylemeliyim. Sorunum ve bağlamım göz önüne alındığında, webAPI işleminin eşzamansız hale getirilmesi bana nasıl fayda sağlar?

Spesifik örneğinizde, işlem hiç eşzamansız değildir, bu nedenle yaptığınız şey eşzamansızdır. Sadece bir ileti dizisini serbest bırakıp diğerini engelliyorsunuz. Bunun için bir neden yok, çünkü tüm iş parçacıkları iş parçacığı havuzu iş parçacıklarıdır (bir GUI uygulamasının aksine).

"Eşzamansız eşzamanlı olmayan" tartışmamda, dahili olarak eşzamanlı olarak uygulanan bir API'niz varsa, eşzamanlı yöntemi basitçe saran eşzamansız bir eşdüzey göstermemenizi şiddetle tavsiye ettim Task.Run.

Gönderen Zaman uyumsuz yöntemler için eşzamanlı sarmalayıcıları göstermeli miyim?

Bununla birlikte async, oturan ve bir sonuç için bekleyen bir iş parçacığını engellemek yerine gerçek bir eşzamansız işlemin (genellikle G / Ç) olduğu WebAPI çağrıları yaparken iş parçacığı iş parçacığı havuzuna geri döner ve böylece başka bir işlem gerçekleştirebilir. Her şeyden öte bu, uygulamanızın daha az kaynakla daha fazlasını yapabileceği ve bu da ölçeklenebilirliği artıracağı anlamına gelir.

Bir yaklaşım (bunu müşteri uygulamalarında başarılı bir şekilde kullandım) uzun işlemleri çalışan iş parçacıklarıyla çalıştıran bir Windows Hizmetine sahip olmak ve ardından engelleme işlemi tamamlanıncaya kadar iş parçacıklarını serbest bırakmak için bunu IIS'de yapmak olabilir: Not, bu varsayılır sonuçlar bir tabloda (jobId ile tanımlanan satırlar) ve kullanımdan birkaç saat sonra bunları temizleyen daha temiz bir işlemde saklanır.

"Sorunum ve bağlamım göz önüne alındığında, webAPI işleminin eşzamansız hale getirilmesi bana nasıl fayda sağlar?" "oldukça uzun bir işlem" olduğu düşünüldüğünde, ms yerine birkaç saniye düşünüyorum, bu yaklaşım IIS iş parçacıklarını serbest bırakıyor. Açıkçası, kendisi de kaynak alan bir Windows hizmeti çalıştırmanız gerekir, ancak bu yaklaşım, yavaş sorgulardan oluşan bir selin sistemin diğer bölümlerinden iş parçacığı çalmasını önleyebilir.

// GET api/<controller>
[HttpGet]
[Route("pharmacies/{pharmacyId}/page/{page}/{filter?}")]
public async Task<CartTotalsDTO> GetProductsWithHistory(Guid pharmacyId, int page, string filter = null ,[FromUri] bool refresh = false)
{
        var jobID = Guid.NewGuid().ToString()
        var job = new Job
        {
            Id = jobId,
            jobType = "GetProductsWithHistory",
            pharmacyId = pharmacyId,
            page = page,
            filter = filter,
            Created = DateTime.UtcNow,
            Started = null,
            Finished = null,
            User =  {{extract user id in the normal way}}
        };
        jobService.CreateJob(job);

        var timeout = 10*60*1000; //10 minutes
        Stopwatch sw = new Stopwatch();
        sw.Start();
        bool responseReceived = false;
        do
        {
            //wait for the windows service to process the job and build the results in the results table
            if (jobService.GetJob(jobId).Finished == null)
            {
                if (sw.ElapsedMilliseconds > timeout ) throw new TimeoutException();
                await Task.Delay(2000);
            }
            else
            {
                responseReceived = true;
            }
        } while (responseReceived == false);

    //this fetches the results from the temporary results table
    return jobService.GetProductsWithHistory(jobId);
}