Call asynchronous method in constructor

 using System;

 using System.ComponentModel;

 using System.Threading.Tasks;

 public sealed class NotifyTaskCompletion<TResult> : INotifyPropertyChanged

 {

   public NotifyTaskCompletion(Task<TResult> task)

   {

     Task = task;

     if (!task.IsCompleted)

     {

       var _ = WatchTaskAsync(task);

     }

   }

   private async Task WatchTaskAsync(Task task)

   {

     try

     {

       await task;

     }

     catch

     {

     }

     var propertyChanged = PropertyChanged;

     if (propertyChanged == null)

         return;

     propertyChanged(this, new PropertyChangedEventArgs("Status"));

     propertyChanged(this, new PropertyChangedEventArgs("IsCompleted"));

     propertyChanged(this, new PropertyChangedEventArgs("IsNotCompleted"));

     if (task.IsCanceled)

     {

       propertyChanged(this, new PropertyChangedEventArgs("IsCanceled"));

     }

     else if (task.IsFaulted)

     {

       propertyChanged(this, new PropertyChangedEventArgs("IsFaulted"));

       propertyChanged(this, new PropertyChangedEventArgs("Exception"));

       propertyChanged(this,

         new PropertyChangedEventArgs("InnerException"));

       propertyChanged(this, new PropertyChangedEventArgs("ErrorMessage"));

     }

     else

     {

       propertyChanged(this,

         new PropertyChangedEventArgs("IsSuccessfullyCompleted"));

       propertyChanged(this, new PropertyChangedEventArgs("Result"));

     }

   }

   public Task<TResult> Task { get; private set; }

   public TResult Result { get { return (Task.Status == TaskStatus.RanToCompletion) ?

     Task.Result : default(TResult); } }

   public TaskStatus Status { get { return Task.Status; } }

   public bool IsCompleted { get { return Task.IsCompleted; } }

   public bool IsNotCompleted { get { return !Task.IsCompleted; } }

   public bool IsSuccessfullyCompleted { get { return Task.Status ==

     TaskStatus.RanToCompletion; } }

   public bool IsCanceled { get { return Task.IsCanceled; } }

   public bool IsFaulted { get { return Task.IsFaulted; } }

   public AggregateException Exception { get { return Task.Exception; } }

   public Exception InnerException { get { return (Exception == null) ?

     null : Exception.InnerException; } }

   public string ErrorMessage { get { return (InnerException == null) ?

     null : InnerException.Message; } }

   public event PropertyChangedEventHandler PropertyChanged;

 }

An updated ViewModel using NotifyTaskCompletion<T> would look like this:

 public class MainViewModel

 {

   public MainViewModel()

   {

     UrlByteCount = new NotifyTaskCompletion<int>(

       MyStaticService.CountBytesInUrlAsync("http://www.example.com"));

   }

   public NotifyTaskCompletion<int> UrlByteCount { get; private set; }

 }

 <Window x:Class="MainWindow"

         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

   <Window.Resources>

     <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"/>

   </Window.Resources>

   <Grid>

     <!-- Busy indicator -->

     <Label Content="Loading..." Visibility="{Binding UrlByteCount.IsNotCompleted,

       Converter={StaticResource BooleanToVisibilityConverter}}"/>

     <!-- Results -->

     <Label Content="{Binding UrlByteCount.Result}" Visibility="{Binding

       UrlByteCount.IsSuccessfullyCompleted,

       Converter={StaticResource BooleanToVisibilityConverter}}"/>

     <!-- Error details -->

     <Label Content="{Binding UrlByteCount.ErrorMessage}" Background="Red"

       Visibility="{Binding UrlByteCount.IsFaulted,

       Converter={StaticResource BooleanToVisibilityConverter}}"/>

   </Grid>

 </Window>

From: https://msdn.microsoft.com/en-us/magazine/dn605875.aspx

巴特西

Call asynchronous method in constructor

最新文章

热门文章