Erstellen einer asynchronen Webservice-Methode

Question

Ich habe versucht, Async-Methoden zu lesen, und versuche nun, meine eigene Async-Methode zu erstellen. Die Methode ist ein Webservice-Aufruf, der eine Liste von Fehlerprotokollen zurückgibt. Ich bin mir nicht sicher, ob ich es richtig verstanden habe, also dachte ich, ich würde meinen Code teilen, um zu sehen, ob ich etwas anderes machen sollte.

Ich möchte nur, dass der Code eine Liste von Fehlerprotokollen zurückgibt, indem eine Methode aufgerufen wird GetAllErrorLogs(), das ist eine synchronisierte Methode. Da es eine Sekunde dauern kann, um alle Fehlerprotokolle zu holen, möchte ich die Möglichkeit haben, andere Dinge zu tun, sobald ich die GetAllErrorLogs() Methode aufgerufen habe. Hier ist der Code.

[WebMethod] 
public async Task<List<ErrorLog>> GetAllErrorLogs() 
{ 
    List<ErrorLog> errorLogs = new List<ErrorLog>(); 

    await System.Threading.Tasks.Task.Run(() => { 
     errorLogs = ErrorLogRepository.GetAllErrorLogs(); 
    }); 


    if (errorLogs == null) 
     return new List<ErrorLog>(); 

    return errorLogs; 
} 

Vielen Dank!

Answer 1

Ich hielt vor kurzem einen Vortrag bei ThatConference auf async on the server side, und ich adressiere dieses Problem in den Folien.

Auf der Serverseite möchten Sie die Verwendung von Task.Run und anderen Konstrukten, die in der Warteschlange arbeiten, vermeiden. Halten Sie Thread-Pool-Threads so weit wie möglich für die Verarbeitung von Anforderungen bereit.

Also idealerweise würde Ihr Repository eine asynchrone Methode GetAllErrorLogsAsync haben, die selbst asynchron wäre. Wenn GetAllErrorLogs nicht asynchron sein kann, dann können Sie es auch direkt aufrufen (Entfernen der await Task.Run).

Da es eine Sekunde dauern kann, um alle Fehlerprotokolle zu holen, möchte ich die Möglichkeit haben, andere Sachen zu machen, sobald ich die GetAllErrorLogs() Methode aufgerufen habe.

Wenn Sie einen GetAllErrorLogsAsync zur Verfügung haben, kann dies einfach mit Task.WhenAll durchgeführt werden. Wenn GetAllErrorLogs jedoch synchron ist, können Sie dies nur tun, indem Sie in Ihrer Anforderung parallel arbeiten (z. B. mehrere Aufrufe an Task.Run, gefolgt von Task.WhenAll).

Parallelcode auf dem Server muss mit großer Beklemmung angegangen werden. Dies ist nur in sehr begrenzten Szenarien akzeptabel. Der gesamte Punkt async auf der Serverseite ist weniger Threads pro Anfrage zu verwenden, und wenn Sie mit der Parallelisierung beginnen, tun Sie das Gegenteil: mehrere Threads pro Anfrage. Dies ist nur sinnvoll, wenn Sie wissen, dass Ihre Benutzerbasis sehr klein ist. Andernfalls werden Sie die Skalierbarkeit Ihres Servers beeinträchtigen.

Answer 2

fand ich diese große Codeproject ausführlichen Artikel darüber, wie die

http://www.codeproject.com/Articles/600926/Asynchronous-web-services-call-in-ASP-NET

Answer 3

** Diese potenziell falsch ist, lesen Sie Kommentare oder Spin-off Frage bei HttpContext.Current after an await

Wenn ErrorLogRepository.GetAllErrorLogs() zu erreichen, ist nicht Thread -safe, es wird seltsame Bugs verursachen und möglicherweise ausschließen. Stellen Sie sicher, dass Ihr Code für Multithread-Operationen bereit ist, bevor Sie zu asynchronen Methoden wechseln. Dies ist offensichtlich eine sehr triviale Empfehlung, wird aber oft übersehen. Wenn Sie beispielsweise in Ihren Methoden auf HttpContext.Current verweisen, wird Ihr Code in der asynchronen Methode und manchmal sogar nach await sterben. Der Grund dafür ist, dass der Code innerhalb des asynchronen Blocks möglicherweise in einem separaten Thread ausgeführt wird, der nicht auf dieselbe HttpContext.Current thread-static -Eigenschaft zugreifen kann, und await wird in zwei Methoden kompiliert. Der gesamte Code vor einer await wird in einem Thread ausgeführt und ruft den Code nach einem await-Schlüsselwort als Fortsetzung auf, möglicherweise jedoch auch in einem anderen Thread. Manchmal funktioniert Ihr Code sogar in einem asynchronen Block, nur um unerwartet zu ersticken, wenn er aus dem Async zurückkommt, was Sie für einen synchronen Teil Ihres Codes halten (aber in Wirklichkeit ist alles nach einem await Schlüsselwort nicht garantiert) der ursprüngliche Thread sein).

Answer 4

Hier finden Sie einige Produktionscode ...

using System.Web.Http; 
using AysncTask = System.Threading.Tasks.Task; 

public class myController : ApiControllerBase 
{ 
     [HttpPut] 
     [Route("api/cleardata/{id}/{requestId}/")] 
     public async AysncTask ClearData(Guid id, Guid requestId) 
     { 
      try 
      { 
       await AysncTask.Run(() => DoClearData(id, requestId)); 
      } 
      catch (Exception ex) 
      { 
       throw new Exception("Exception in myController.ClearData", ex); 
      } 
     } 
} 

Answer 5

Ausnahmen Async Handhabung sehr wichtig auch sehr .. ist, obwohl dies für eine Windows-Konsole app ist, sollten die gleichen Grundsätze gelten.

Quelle: https://blogs.msdn.microsoft.com/ptorr/2014/12/10/async-exceptions-in-c/

using System; 
    using System.Runtime.CompilerServices; 
    using System.Threading; 
    using System.Threading.Tasks; 

    namespace AsyncAndExceptions 
    { 
class Program 
{ 
    static void Main(string[] args) 
    { 
    AppDomain.CurrentDomain.UnhandledException += (s, e) => Log("*** Crash! ***", "UnhandledException"); 
    TaskScheduler.UnobservedTaskException += (s, e) => Log("*** Crash! ***", "UnobservedTaskException"); 

    RunTests(); 

    // Let async tasks complete... 
    Thread.Sleep(500); 
    GC.Collect(3, GCCollectionMode.Forced, true); 
    } 

    private static async Task RunTests() 
    { 
    try 
    { 
     // crash 
     // _1_VoidNoWait(); 

     // crash 
     // _2_AsyncVoidAwait(); 

     // OK 
     // _3_AsyncVoidAwaitWithTry(); 

     // crash - no await 
     // _4_TaskNoWait(); 

     // crash - no await 
     // _5_TaskAwait(); 

     // OK 
     // await _4_TaskNoWait(); 

     // OK 
     // await _5_TaskAwait(); 
    } 
    catch (Exception ex) { Log("Exception handled OK"); } 

    // crash - no try 
    // await _4_TaskNoWait(); 

    // crash - no try 
    // await _5_TaskAwait(); 
    } 

    // Unsafe 
    static void _1_VoidNoWait() 
    { 
    ThrowAsync(); 
    } 

    // Unsafe 
    static async void _2_AsyncVoidAwait() 
    { 
    await ThrowAsync(); 
    } 

    // Safe 
    static async void _3_AsyncVoidAwaitWithTry() 
    { 
    try { await ThrowAsync(); } 
    catch (Exception ex) { Log("Exception handled OK"); } 
    } 

    // Safe only if caller uses await (or Result) inside a try 
    static Task _4_TaskNoWait() 
    { 
    return ThrowAsync(); 
    } 

    // Safe only if caller uses await (or Result) inside a try 
    static async Task _5_TaskAwait() 
    { 
    await ThrowAsync(); 
    } 

    // Helper that sets an exception asnychronously 
    static Task ThrowAsync() 
    { 
    TaskCompletionSource tcs = new TaskCompletionSource(); 
    ThreadPool.QueueUserWorkItem(_ => tcs.SetException(new Exception("ThrowAsync"))); 
    return tcs.Task; 
    } 
    internal static void Log(string message, [CallerMemberName] string caller = "") 
    { 
    Console.WriteLine("{0}: {1}", caller, message); 
    } 
} 

}