Warum sollte ich asynchrone WebAPI-Vorgänge erstellen, anstatt solche zu synchronisieren?

Ich habe die folgende Operation in einer von mir erstellten Web-API:

// 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);
}

Der Aufruf dieses Webservices erfolgt über einen Jquery Ajax-Aufruf auf folgende Weise:

$.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);
      }          
  });

Ich habe einige Entwickler gesehen, die die vorherige Operation folgendermaßen implementieren:

// 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));
}

Ich muss jedoch sagen, dass GetProductsWithHistory () eine ziemlich lange Operation ist. Wie kann ich angesichts meines Problems und meines Kontextes davon profitieren, wenn ich die webAPI-Operation asynchron mache?

In Ihrem speziellen Beispiel ist der Vorgang überhaupt nicht asynchron. Sie tun also asynchron über synchron. Sie geben nur einen Thread frei und blockieren einen anderen. Es gibt keinen Grund dafür, da alle Threads Thread-Pool-Threads sind (im Gegensatz zu einer GUI-Anwendung).

In meiner Diskussion über "Async over Sync" habe ich dringend empfohlen, dass Sie, wenn Sie eine API haben, die intern synchron implementiert ist, kein asynchrones Gegenstück verfügbar machen sollten, das die synchrone Methode einfach einschließt Task.Run.

Von Soll ich synchrone Wrapper für asynchrone Methoden verfügbar machen?

Wenn Sie jedoch WebAPI-Aufrufe asyncausführen, bei denen eine tatsächliche asynchrone Operation (normalerweise E / A) vorliegt, anstatt einen Thread zu blockieren, der sich befindet und auf ein Ergebnis wartet, kehrt der Thread zum Thread-Pool zurück und kann so eine andere Operation ausführen. Insgesamt bedeutet dies, dass Ihre Anwendung mit weniger Ressourcen mehr erreichen kann und die Skalierbarkeit verbessert.

Ein Ansatz könnte sein (ich habe dies erfolgreich in Kundenanwendungen verwendet), dass ein Windows-Dienst die langwierigen Vorgänge mit Arbeitsthreads ausführt und dies dann in IIS ausführt, um die Threads freizugeben, bis der Blockierungsvorgang abgeschlossen ist: Hinweis, dies setzt voraus Die Ergebnisse werden in einer Tabelle (durch jobId gekennzeichnete Zeilen) gespeichert und einige Stunden nach der Verwendung durch einen saubereren Prozess bereinigt.

Um die Frage zu beantworten: "Wie kann ich angesichts meines Problems und meines Kontexts davon profitieren, wenn die webAPI-Operation asynchron ausgeführt wird?" Da es sich um eine "ziemlich lange Operation" handelt, denke ich eher an viele Sekunden als an ms, werden durch diesen Ansatz IIS-Threads freigegeben. Natürlich müssen Sie auch einen Windows-Dienst ausführen, der selbst Ressourcen beansprucht, aber dieser Ansatz könnte verhindern, dass eine Flut langsamer Abfragen Threads aus anderen Teilen des Systems stiehlt.

// 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);
}