Windows 8 - warten auf die Aufgabe<Bool> - async-Aufruf wieder auf abgeschlossen Zuhörer erforderlich

Ich habe eine Funktion welche eine Datei öffnet, die aus dem Speicher und kehrt einen booleschen angegeben, dass die Datei geöffnet einwandfrei.

private async Task<bool> SaveImage()
{
    try
    {
        await filesave.openAsync(FileAccessMode.ReadWrite)
    }
    catch()
    {
        return false;
    }

    return true;
}

Möchte ich nennen, die erwarten SaveImage () - Funktion, aber irgendwie wollen die einen listener/event-handler, die sagt mir, wenn dies abgeschlossen.. nach der Fertigstellung habe ich aktualisieren wollen mein layout mit neuen Daten. Wie ist das möglich mit der neuen WINRT-async/await-async-Methode für windows 8? ist es ein umgehen/ersetzen.

Wie kann ich setup eine event-handler-Art-Szenario? (komplett)

InformationsquelleAutor user849953 | 2012-08-06

4

Du nur await rufen Sie Ihre Methode, und Folgen Sie es mit den code, der ausgeführt werden soll, wenn es fertig ist. Sie nicht brauchen, um manuell die Registrierung eines Ereignishandlers.
```
var succeeded = await SaveImage();
//Because of the "await" keyword in the above line, the current method
//will not continue until "SaveImage" has completed its async work and
//signaled its Task
if (succeeded) { ... }
```
Natürlich, da der obige code verwendet die await Schlüsselwort, es muss in eine Methode, die auch markiert async. Wenn diese Methode muss das signal seiner Fertigstellung seine Anrufer, dann sollte es auch wieder ein Task oder Task<T>; zum Beispiel:
```
private async Task<string> MyHelperMethod() {
    var succeeded = await SaveImage();
    if (succeeded)
        return "Success";
    else
        return "Failure";
}
//then, in some other method:
    var message = await MyHelperMethod();
```
Oder, wenn die Methode aufrufen SaveImage ist das Ende der Zeile -- sagen, es ist der handler für Button's Click event -- dann kann es sein async void:
```
private async void ButtonClick(object sender, EventArgs args) {
    var succeeded = await SaveImage();
    if (succeeded) { ... }
}
```
Hinweis: obwohl Sie den rest der Zeilen in der Methode warten, bis die erwartete Methode abgeschlossen wird, wird die Methode aufgerufen, die Methode ist gegeben Ablaufsteuerung der Ausführung. Siehe msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx

InformationsquelleAutor Joe White

Joe ' s Antwort sieht toll aus, aber wenn Sie darauf bestehen, mit einem Ereignis - zum Beispiel, wenn Sie Ihre SaveImage () - Aufrufe sind in verschiedenen Bereichen der code unabhängig von der Aktualisierung des layout - Sie können nur erhöhen ein Ereignis, wenn Ihre operation abgeschlossen ist. Sie können die plain old CLR events, oder verwenden Sie eine pub-sub-pattern Umsetzung wie die EventAggregator von Prism oder Messenger von MVVM Light. Die POCE-version könnte so Aussehen

public event EventHandler<Tuple<StorageFile,bool>> SaveImageCompleted;

private async Task<bool> SaveImage(StorageFile file)
{
    try
    {
        await file.OpenAsync(FileAccessMode.ReadWrite);
    }
    catch
    {
        if (SaveImageCompleted != null)
            SaveImageCompleted(this, new Tuple<StorageFile, bool>(file, false));

        return false;
    }

    if (SaveImageCompleted != null)
        SaveImageCompleted(this, new Tuple<StorageFile, bool>(file, true));

    return true;
}

InformationsquelleAutor Filip Skakun

Dauert dies ein wenig mehr code, ist aber ein SEHR Cooler und nützlicher Umgang mit asynchronen Operationen, Fortschritte, Stornierungen und vollständigen Zustand im Allgemeinen. Diese wurden in einem VS2012 Winrt-Store-App und ich habe es aus eine Schaltfläche klicken, wie Sie hier sehen.

    private void Save_File_Click(object sender, RoutedEventArgs e)
    {
        //create your op, bool = return type, string = progress report
        IAsyncOperationWithProgress<bool, string> op;

        //Call our async operation with progress sending the file name
        op = OpenFileWithProgress("test.txt");

        // not implemented here
        //op.Cancel(); 

        //when we get a progress update...
        op.Progress = (info, progress) =>
        {
            //I'm just giving text feed back to user here
            Debug.WriteLine(progress);
        };
        op.Completed = (info, status) =>
        {
            //check status for completion or cancellation...
            switch (status)
            {
                case AsyncStatus.Completed:
                    // Do your completed work here
                    Debug.WriteLine("Completed");
                    break;
                case AsyncStatus.Canceled:
                    //Operation canceled - not implemented...
                    Debug.WriteLine("Canceled");
                    break;
                default:
                    //default stuff here
                    break;
            }
        };
    }

    public IAsyncOperationWithProgress<bool, string> OpenFileWithProgress(string fileName)
    {
        return System.Runtime.InteropServices.WindowsRuntime.AsyncInfo.Run<bool, string>((token, progress) =>
            Task.Run<bool>(async () =>
            {
                progress.Report("Starting");
                try
                {
                    StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName);
                }
                catch (Exception ex)
                {
                    return false;
                }

                progress.Report("Finished");

                return true;

            }, token));
    }

InformationsquelleAutor CodeChops

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.