[Erledigt] Async & Await richtig verwenden?

Schönen Morgen euch,

eigentlich habe ich gedacht, dass ich das Prinzip von **async **und await verstanden habe, jedoch stoße ich immer wieder auf Blogs, die mir das Gegenteil behaupten. Nun brauche ich einen Rat.

Nehmen wir an, ich habe eine Methode, welche einen langen Prozess abarbeitet. Diese Methode nennen wir mal "DoWork()". Dieses Methode implementiert nicht async oder ähnliches. Ist es sinnvoll für diese Methode jetzt einen asynchronen Wrapper zu basteln, also so etwas wie:

public async Task DoWorkAsync()
{
    await Task.Run(()=> DoWork());
}

Wenn ich diese Methode aufrufe, wird ja nur die Methode "DoWork" in einem anderen Task ausgehürt, meiner Meinung nach, ist das eher parallel anstatt asynchron. So nach dem Motto: "Aus den Augen, aus dem Sinn".

Ist so etwas legitim, oder völliger Quatsch? Ich habe zudem mehrmals gelesen, dass man es möglichst vermeiden sollte, in einer Klassenbibliothek "Task.Run" zu benutzen, warum? Wie sonst, sollte ich dann diesen Wrapper implementieren?

Wie implementiert ihr asynchrone Funktionsaufrufe von "eigenen" Funktionen?

Siehe mein Source auf SchwabenCode - AsyncAll.
Auf ähnliche Weise macht das auch Microsoft selbst innerhalb des .NET Frameworks.

public Task DoWorkAsync()
{
   return AsyncAll.ExecuteAsync( ( ) => DoWork( ) );
}

// Oder mit typisierter Rückgabe

public Task<String> DoWorkAsync()
{
   return AsyncAll.GetAsyncResult( ( ) => DoWork( ) );
}

Bei Dir fehlt die Exception-Behandlung und es wenn dann wäre

public Task DoWorkAsync()
{
    return Task.Run(()=> DoWork());
}

public async String Other()
{
  var do = await DoWorkAsync();
  return "Erledigt";
}

Und ja, das ist asynchron und nicht parallel.
Dass man Task.Run() nicht verwenden sollte habe ich noch nie gesehen. Es ist halt erst ab 4.5 verfügbar, weshalb man wegen Abwärtskompatibilität meist noch StartNew nimmt (was nichts anderes ist).

Okay, ich danke dir. Dass Exception-Handling fehlt ist mir klar, wollte nur auf das wesentliche eingehen.

Das Thema mit "Task.Run()" innerhalb einer Bibliothek meine ich, irgendwo mal auf Stackoverflow aufgeschnappt zu haben, werde mal schauen, ob ich das noch einmal finde.

Grüße Marcel

Zu dem Thema empfehle ich noch folgenden Artikel: Should I expose asynchronous wrappers for synchronous methods?

Kernaussage: Verwende Task.Run() wenn möglich nicht in Bibliotheken, um aus synchronen Methoden asychrone zu machen, da die Erwartungshaltung der Entwickler oft darin liegt, eine höhere Skalierbarkeit zu erreichen und das Gegenteil ist dann der Fall.