Start async-Methode als Thread oder als Aufgabe

Ich bin neu C#s await/async und derzeit spielen Sie ein bisschen herum.

In meinem Szenario habe ich eine einfache client-Objekt, das hat eine WebRequest Eigenschaft. Der Kunde sollte senden Sie in regelmäßigen Abständen alive-Nachrichten über die WebRequests RequestStream.
Dies ist der Konstruktor des client-Objekts:

public Client()
{
    _webRequest = WebRequest.Create("some url");
    _webRequest.Method = "POST";

    IsRunning = true;

    //--> how to start the 'async' method (see below)
}

und die async-lebendig-sender-Methode

private async void SendAliveMessageAsync()
{
    const string keepAliveMessage = "{\"message\": {\"type\": \"keepalive\"}}";
    var seconds = 0;
    while (IsRunning)
    {
        if (seconds % 10 == 0)
        {
            await new StreamWriter(_webRequest.GetRequestStream()).WriteLineAsync(keepAliveMessage);
        }

        await Task.Delay(1000);
        seconds++;
    }
}

Wie sollte die Methode gestartet werden?

neuen Thread(SendAliveMessageAsync).Start();

oder

Aufgabe.Run(SendAliveMessageAsync); //änderung der Rückgabe-Typ zu Aufgabe

oder

erwarten SendAliveMessageAsync(); //schlägt fehl, da der Konstruktor ist nicht async

Meine Frage ist, mehr über mein persönliches Verständnis von await/async ich glaube, das ist vielleicht falsch in einigen Punkten.

Die Dritte Möglichkeit ist, werfen

The 'await' operator can only be used in a method or lambda marked with the 'async' modifier
Zuerst müssen Sie entscheiden, ob dies ist ein Feuer-and-forget-Methode oder etwas, das Sie warten möchten.
Es ist in der Tat ein Feuer-und-vergessen werden, da es einfach starten sollte ein Thread senden alive-Meldungen.
Dann await ist sinnlos, da man nicht wirklich daran interessiert, zu warten, für Sie zu vervollständigen. Ich würde einfach den thread Ansatz dann. Persönlich halte ich Aufgaben wie kleinere enthaltenen Einheiten von Arbeit, die ausgeführt werden muss asynchron.
Sie sollten nie nennen new StreamWriter(_webRequest.GetRequestStream()).WriteLineAsync(keepAliveMessage) - erwarten-oder anders - als StreamWriter ist IDisposable und müssen ordnungsgemäß entsorgt werden, sobald verwendet. Diese syntax ermöglicht es Ihnen nicht zu nennen .Dipose().
Gut und gültig-Punkt. Aber dies ist nicht der funktionierende code. Die StreamWriter ist auch die Initialisierung im Konstruktor, sondern wird der Einfachheit halber hier nicht gezeigt.

InformationsquelleAutor KingKerosin | 2016-01-15

  1. 7

    Wie sollte die Methode gestartet werden?

    Ich Stimme für "keine der genannten". 🙂

    "Feuer-und-vergessen" ist eine schwierige Szenario zu behandeln, richtig. Insbesondere die Fehlerbehandlung ist immer problematisch. In diesem Fall async void mag Sie überraschen.

    Ich lieber explizit speichern die Aufgaben, wenn ich mich nicht awaiting Sie sofort:

    private async Task SendAliveMessageAsync();

public Task KeepaliveTask { get; private set; }

public Client()
{
  ...
  KeepaliveTask = SendAliveMessageAsync();
}

    Diese mindestens die Konsumenten von Client zu erkennen und wiederherstellen von Ausnahmen von der SendAliveMessageAsync Methode.

    On a side note, das Muster ist fast gleichwertig zu meinem "asynchrone Initialisierung-Muster.

    InformationsquelleAutor Stephen Cleary

  2. 3

    Bearbeitet wie die Vorherige Antwort war falsch:

    Als es im Konstruktor, ich glaube, Sie hätte sich zu drehen, ein neues thread dafür. Ich persönlich würde das tun, mit

    Aufgabe.Factory.StartNew(() => SendAliveMessageAsync());

    Der code wird im Konstruktor. Aufruf await funktioniert nicht in Konstruktoren.
    Hoppla, du hast Recht.
    Gibt es einen Unterschied zwischen Task.Run und Task.Factory.StartNew? Oder ist das nur deine persönliche Meinung?
    Um ehrlich zu sein, ich benutze Aufgabe.Factory.StartNew aus macht der Gewohnheit; Aufgabe.Laufen ist so ziemlich eine Verknüpfung für Sie, so dass, wenn Sie lieber verwenden, gehen Sie nach rechts weiter.

    InformationsquelleAutor John Clifford

  3. 0

    Da es ein Feuer-und-vergessen Betrieb nehmen, sollten Sie starten Sie es durch 

    SendAliveMessageAsync();

    Beachten Sie, dass await startet keine neue Task. Es ist nur syntaktischer Zucker, um zu warten, bis ein Task abgeschlossen.

    Ein neuer thread wird gestartet mit Task.Run.

    Also innerhalb SendAliveMessageAsync sollten Sie beginnen, eine neue Aufgabe:

    private async Task SendAliveMessageAsync()
{
    const string keepAliveMessage = "{\"message\": {\"type\": \"keepalive\"}}";
    await Task.Run( () => {
        var seconds = 0;
        while (IsRunning)
        {
            if (seconds % 10 == 0)
            {
                await new StreamWriter(_webRequest.GetRequestStream()).WriteLineAsync(keepAliveMessage);
            }

            await Task.Delay(1000);
            seconds++;
        }
    });
}
    Der code wird im Konstruktor. Aufruf await funktioniert nicht in Konstruktoren.
    Aber ruft es mit SendAliveMessageAsync(); nicht synchron und deshalb der Konstruktor wird nie wieder (weil die Methoden while)?
    oh wow, wie konnte ich das übersehen. Danke für die Erinnerung
    Ja, das loop in einem Konstruktor ist schlecht. Konstruktoren sollten so schnell wie möglich und sollte nie Risiko-eine Ausnahme ausgelöst wird.
    siehe mein edit

    InformationsquelleAutor Domysee

  4. 0

    Hier ist eine option, da kann man das auch nicht nennen await aus in einem Konstruktor.

    Ich würde vorschlagen, mit Microsoft Reaktive Framework (NuGet "Rx-Main").

    Würde der code wie folgt Aussehen:

    public class Client
{
    System.Net.WebRequest _webRequest = null;
    IDisposable _subscription = null;

    public Client()
    {
        _webRequest = System.Net.WebRequest.Create("some url");
        _webRequest.Method = "POST";

        const string keepAliveMessage = "{\"message\": {\"type\": \"keepalive\"}}";

        var keepAlives =
            from n in Observable.Interval(TimeSpan.FromSeconds(10.0))
            from u in Observable.Using(
                () => new StreamWriter(_webRequest.GetRequestStream()),
                sw => Observable.FromAsync(() => sw.WriteLineAsync(keepAliveMessage)))
            select u;

        _subscription = keepAlives.Subscribe();
    }
}

    Dieser code übernimmt alle threading erforderlich und ordnungsgemäß entsorgt StreamWriter wie es geht.

    Wann immer Sie wollen, zu stoppen die keep alives einfach anrufen _subscription.Dispose().

    InformationsquelleAutor Enigmativity

  5. 0

    In deinem code gibt es keine Notwendigkeit, mit async/await, richten Sie einfach einen neuen thread auf, führen lange den Betrieb.

    private void SendAliveMessage()
{
    const string keepAliveMessage = "{\"message\": {\"type\": \"keepalive\"}}";
    var sreamWriter = new StreamWriter(_webRequest.GetRequestStream());
    while (IsRunning)
    {
        sreamWriter.WriteLine(keepAliveMessage);
        Thread.Sleep(10 * 1000);
    }    
}

    Mit Task.Factory.StartNew(SendAliveMessage, TaskCreationOptions.LongRunning) um den Vorgang auszuführen.

    Wenn Sie wirklich wollen, um mit async/await-Muster, nennen es einfach im Konstruktor erwarten, ohne Modifizierer und vergessen Sie es.

    public Client()
{
    _webRequest = WebRequest.Create("some url");
    _webRequest.Method = "POST";

    IsRunning = true;

    SendAliveMessageAsync();    //just call it and forget it.
}

    Ich denke, es ist keine gute Idee einen lange Laufenden thread oder mithilfe der async/await-Muster. Timer vielleicht besser geeignet in dieser situation.

    InformationsquelleAutor cFish

Schreibe einen Kommentar