Asynchrone Implementierung von IValueConverter

Werden Sie wahrscheinlich nicht wollen, zu nennen Task.Result, für ein paar Gründe.

Erstens, wie ich im detail erklären, auf meinem blog, Sie können deadlock es sei denn, Ihr async code ist geschrieben worden über ConfigureAwait überall. Zweitens, werden Sie wahrscheinlich nicht wollen, (synchron -) block UI; besser wäre es, vorübergehend einblenden "wird geladen..." oder leere Bild beim Lesen von der Festplatte, und update, wenn das Lesen abgeschlossen ist.

So, ich persönlich würde das Teil in meinem ViewModel, nicht ein Wert-Konverter. Ich habe einen blog-Beitrag beschreibt einige databinding-freundlichen Möglichkeiten, um die asynchrone Initialisierung. Das wäre meine erste Wahl. Es fühlt sich einfach nicht richtig an eine Wert Konverter Auftakt asynchrone hintergrund-Operationen.

Jedoch, wenn Sie als habe Sie Ihr design und denke wirklich, dass eine asynchrone Wert Konverter, was Sie brauchen, dann muss man ein bisschen erfinderisch. Das problem mit Wert-Wandlern ist, dass Sie haben synchron sein: die Datenbindung beginnt bei den Daten-Kontext, wertet Sie den Pfad, und dann startet eine Konvertierung. Nur die Daten, die Kontext-und Pfad-support-Benachrichtigungen ändern.

Also, Sie haben, um einen (synchronen) Wert-Konverter in Ihrem datenkontext, um wandeln Sie Ihre original-Wert in einem databinding-freundliche Task-wie-Objekt und dann Ihr Eigentum-Bindung nur eine der Eigenschaften auf die Task-wie Objekt, um das Ergebnis zu erhalten.

Hier ist ein Beispiel was ich meine:

<TextBox Text="" Name="Input"/>
<TextBlock DataContext="{Binding ElementName=Input, Path=Text, Converter={local:MyAsyncValueConverter}}"
           Text="{Binding Path=Result}"/>

Den TextBox ist nur ein Eingabe-Feld. Die TextBlock setzt zuerst seine eigenen DataContext zu den TextBox's input text läuft über eine "asynchrone" - Konverter. TextBlock.Text eingestellt ist, um die Result von diesem Konverter.

Der Konverter ist Recht einfach:

public class MyAsyncValueConverter : MarkupExtension, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var val = (string)value;
        var task = Task.Run(async () =>
        {
            await Task.Delay(5000);
            return val + " done!";
        });
        return new TaskCompletionNotifier<string>(task);
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return null;
    }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        return this;
    }
}

Den Konverter zum ersten mal startet eine asynchrone operation warten Sie 5 Sekunden und fügen Sie dann " fertig!" an das Ende des input-string. Das Ergebnis der Konverter kann nicht nur eine schlichte Task weil Task nicht umsetzen IPropertyNotifyChanged, also ich bin mit einem Typ, der sein wird in der nächsten Version von meinem AsyncEx Bibliothek. Es sieht wie folgt aus (vereinfacht für dieses Beispiel; volle Quelle ist erhältlich):

//Watches a task and raises property-changed notifications when the task completes.
public sealed class TaskCompletionNotifier<TResult> : INotifyPropertyChanged
{
    public TaskCompletionNotifier(Task<TResult> task)
    {
        Task = task;
        if (!task.IsCompleted)
        {
            var scheduler = (SynchronizationContext.Current == null) ? TaskScheduler.Current : TaskScheduler.FromCurrentSynchronizationContext();
            task.ContinueWith(t =>
            {
                var propertyChanged = PropertyChanged;
                if (propertyChanged != null)
                {
                    propertyChanged(this, new PropertyChangedEventArgs("IsCompleted"));
                    if (t.IsCanceled)
                    {
                        propertyChanged(this, new PropertyChangedEventArgs("IsCanceled"));
                    }
                    else if (t.IsFaulted)
                    {
                        propertyChanged(this, new PropertyChangedEventArgs("IsFaulted"));
                        propertyChanged(this, new PropertyChangedEventArgs("ErrorMessage"));
                    }
                    else
                    {
                        propertyChanged(this, new PropertyChangedEventArgs("IsSuccessfullyCompleted"));
                        propertyChanged(this, new PropertyChangedEventArgs("Result"));
                    }
                }
            },
            CancellationToken.None,
            TaskContinuationOptions.ExecuteSynchronously,
            scheduler);
        }
    }

    //Gets the task being watched. This property never changes and is never <c>null</c>.
    public Task<TResult> Task { get; private set; }

    Task ITaskCompletionNotifier.Task
    {
        get { return Task; }
    }

    //Gets the result of the task. Returns the default value of TResult if the task has not completed successfully.
    public TResult Result { get { return (Task.Status == TaskStatus.RanToCompletion) ? Task.Result : default(TResult); } }

    //Gets whether the task has completed.
    public bool IsCompleted { get { return Task.IsCompleted; } }

    //Gets whether the task has completed successfully.
    public bool IsSuccessfullyCompleted { get { return Task.Status == TaskStatus.RanToCompletion; } }

    //Gets whether the task has been canceled.
    public bool IsCanceled { get { return Task.IsCanceled; } }

    //Gets whether the task has faulted.
    public bool IsFaulted { get { return Task.IsFaulted; } }

    //Gets the error message for the original faulting exception for the task. Returns <c>null</c> if the task is not faulted.
    public string ErrorMessage { get { return (InnerException == null) ? null : InnerException.Message; } }

    public event PropertyChangedEventHandler PropertyChanged;
}

Indem Sie diese Stücke zusammen, die wir erstellt haben, eine asynchrone Daten-Kontext, ist das Ergebnis ein Wert Konverter. Die databinding-freundliche Task - wrapper verwenden Sie einfach die Standardeinstellung Ergebnis (in der Regel null oder 0), bis die Task abgeschlossen. Also der wrapper ist Result ist ganz anders als Task.Result: es wird nicht synchron block und es besteht keine Gefahr von Deadlocks.

Aber noch einmal betonen: ich würde entscheiden, asynchrone Logik in die ViewModel-eher als eine Wert-Konverter.

InformationsquelleAutor der Antwort Stephen Cleary