Feuer Rückruf nach async-Task-Methode

Muss ich Feuer einen Rückruf, wenn der foreach Schleife beendet hat, sucht sich durch jedes Element int die List<>. 

private async void startSearchBtn_Click(object sender, EventArgs e)
{
    await Search(files, selectTxcDirectory.SelectedPath, status);
}

private static async Task Search(List<string> files, string path, Label statusText)
{
    foreach (string file in files)
    {
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(file);

        statusText.Text = "Started scanning...";
        using (XmlReader reader = XmlReader.Create(new StringReader(xmlDoc.InnerXml), new XmlReaderSettings() { Async = true }))
        {
            while (await reader.ReadAsync())
            {
                if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "LineName"))
                {
                    Console.WriteLine(reader.ReadInnerXml());
                }
            }
        }
    }
}

Ist das möglich und wenn ja, wie kann es getan werden?

  • Warum nicht einen Delegaten übergeben als parameter und rufen Sie im foreach Schleife, wo Sie brauchen, um? Bin ich etwas fehlt?
  • msdn.microsoft.com/it-it/library/system.asynccallback.aspx
  • Sie sind an nichts fehlt, es ist, weil ich nicht weiß, was passieren einen Delegaten als Parameter aufrufen und es in der foreach-Schleife wird 😎 Könntest du bitte diesen post als Antwort?
  • Ich habe als Antwort. überprüfen Sie, wenn dir das hilft
InformationsquelleAutor jskidd3 | 2013-09-25
  1. 19

    Es ist sehr einfach, geben Sie einfach eine Methode als Delegierter in-parameter. dann rufen Sie es, wo immer Sie brauchen. 

    private async void startSearchBtn_Click(object sender, EventArgs e)
{
    await Search(files, selectTxcDirectory.SelectedPath, status, SearchCompleted); //<-- pass the callback method here
}

private static async Task Search(List<string> files, string path, Label statusText, Action<string> callback)
{
    foreach (string file in files)
    {
        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(file);

        statusText.Text = "Started scanning...";
        using (XmlReader reader = XmlReader.Create(new StringReader(xmlDoc.InnerXml), new XmlReaderSettings() { Async = true }))
        {
            while (await reader.ReadAsync())
            {
                if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == "LineName"))
                {
                    Console.WriteLine(reader.ReadInnerXml());
                }
            }
        }

        //Here you're done with the file so invoke the callback that's it.
        callback(file); //pass which file is finished
    }
}

private static void SearchCompleted(string file)
{
    //This method will be called whenever a file is processed.
}
    InformationsquelleAutor Sriram Sakthivel
  2. 3

    Ich würde code wie unten. Auf diese Weise, die Sie noch immer verfolgen Sie die anstehende Aufgabe (_pendingSearch), während startSearchBtn_Click bleibt synchron.

    Sollten Sie die Verfolgung von ausstehenden Aufgaben (und in der Lage sein zu stornieren). Ansonsten, kann der Benutzer klicken Sie auf startSearchBtn zweimal in Folge und spawnen zwei recherche-Aufgaben. Diese können möglicherweise immer noch ein gültiges Szenario in Ihrem Fall, aber in der Regel ist es nicht.

    Task _pendingSearch = null;
private void startSearchBtn_Click(object sender, EventArgs e)
{
    //check if is _pendingSearch != null and still pending here

    _pendingSearch = Search(files, 
        selectTxcDirectory.SelectedPath, status).ContinueWith((finishedTask) => 
    {
        //Place your completion callback code here
    }, TaskScheduler.FromCurrentSynchronizationContext);
}

private static async Task Search(List<string> files, string path, Label statusText)
{
    //...
}

    [BEARBEITET] Mit await:

    Task _pendingSearch = null;
private async void startSearchBtn_Click(object sender, EventArgs e)
{
    //check if is _pendingSearch != null and still pending here

    _pendingSearch = Search(files, selectTxcDirectory.SelectedPath, status);
    await _pendingSearch;
    //Place your completion callback code here
}
    • Wie ist dies besser, als mit await?
    • mein Punkt ist nicht zu verwenden, fire-and-forget-Ansatz, wenn Benutzer klicken Sie diese Taste mehrere Male. Meine persönliche Präferenz ist nicht async void event-Handler, die speziell zur Vermeidung von Feuer-und-vergessen. Dennoch, es ist möglich zu verfolgen, die anstehende Aufgabe innerhalb async void Methode, ich habe aktualisiert, der code um das zu zeigen.
    • Mit Ausnahme der zwei Stücke von code, der etwas anderes machen. In Ihrem ContinueWith() Beispiel _pendingSearch stellt die Fortsetzung. In der await Beispiel, es ist die Search() Task.
    • Wahr, wie ich kann einfach nicht wickeln startSearchBtn_Click sich als Task. Das ist ein weiterer Grund, warum ich immer noch gerne die ContinueWith Ansatz. Wenn es implementiert die Musterwiderrufsbelehrung und ging ein token zu ContinueWith, würd wirksam kündigen, wird die callback-code zu. Natürlich, die await version kann (und sollte) in diesem Fall behandeln mit try/catch.
    • Sie können alle, dass code in einer Task, würden Sie brauchen nur eine separate async Task Methode (oder vielleicht ein async Task lambda).
    InformationsquelleAutor noseratio
  3. 1

    Da Sie mit await code in startSearchBtn_Click nicht fortgesetzt wird, bis Search fertig ist.

    Alles, was Sie brauchen, ist etwas wie dieses:

    private async void startSearchBtn_Click(object sender, EventArgs e)
{
    await Search(files, selectTxcDirectory.SelectedPath, status);
    //run your callback here
}
    InformationsquelleAutor Kendall Frey
Schreibe einen Kommentar