Implémentation asynchrone d'IValueConverter

Vous ne voulez probablement pas à appeler Task.Result, pour un couple de raisons.

Tout d'abord, comme je l'explique en détail sur mon blog, vous pouvez impasse à moins que votre async code a été écrit à l'aide ConfigureAwait partout. Deuxièmement, vous ne voulez probablement pas à (de façon synchrone) bloquer votre INTERFACE utilisateur; il serait préférable d'afficher temporairement un "chargement..." ou vide de l'image lors de la lecture à partir du disque, et de mettre à jour une fois la lecture terminée.

Donc, personnellement, je voudrais faire cette partie de mon ViewModel, pas un convertisseur de valeurs. J'ai un blog décrivant certains la liaison de données-amicale des façons de faire initialisation asynchrone. Ce serait mon premier choix. Il juste ne se sent pas le droit d'avoir un valeur convertisseur le coup d'envoi asynchrone opérations d'arrière-plan.

Toutefois, si vous avez considéré comme votre conception et de vraiment réfléchir asynchrone valeur convertisseur est ce que vous avez besoin, alors vous devez obtenir un peu plus créatif. Le problème avec les convertisseurs de valeur, c'est qu'ils ont synchrone: la liaison de données commence au contexte de données, d'évaluer le chemin d'accès, puis invoque une valeur de conversion. Seul le contexte de données et le chemin de soutien des notifications de changement.

Donc, vous devez utiliser un (synchrone) convertisseur de valeurs dans votre contexte de données pour convertir votre valeur d'origine dans une liaison de données-friendly Task-comme l'objet et ensuite votre propriété de liaison utilise l'une des propriétés de la Task-comme l'objet pour obtenir le résultat.

Voici un exemple de ce que je veux dire:

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

La TextBox est juste une zone de saisie. Le TextBlock définit d'abord son propre DataContext à la TextBox's saisie de texte en cours d'exécution à travers un "asynchrone" convertisseur. TextBlock.Text est définie à l' Result de ce convertisseur.

Le convertisseur est assez simple:

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;
    }
}

Le convertisseur démarre pour la première fois une opération asynchrone à attendre 5 secondes, puis ajouter " fait!" à la fin de la chaîne d'entrée. Le résultat de ce que le convertisseur ne peut pas être juste une plaine Task parce que Task ne pas mettre en œuvre IPropertyNotifyChanged, donc je suis en utilisant un type qui sera dans la prochaine version de mon AsyncEx bibliothèque. Il ressemble à quelque chose comme ceci (simplifié pour cet exemple; source complet est disponible):

//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;
}

En mettant ces pièces ensemble, nous avons créé une transmission de données asynchrones contexte qui est le résultat d'un convertisseur de valeurs. Le databinding-friendly Task wrapper suffit d'utiliser le résultat par défaut (généralement null ou 0) jusqu'à ce que le Task complète. Si l'emballage est Result est assez différent de Task.Result: il ne sera pas de façon synchrone bloc et il n'y a pas de danger de blocage.

Mais je le répète: j'ai choisi de mettre en logique asynchrone dans le ViewModel plutôt qu'une valeur convertisseur.