Как создать конвертер, который использует async и ждет в Windows 10?

Question

Я переношу свой Windows Phone 8 ImageConverter в Windows 10, но сталкиваюсь с проблемой при использовании Storage API, поскольку он использует async и ждет. Может ли кто-нибудь предложить, что можно использовать для достижения моего требования?

My Windows Phone 8 ЭОП класс ниже

public class ImageConverter : IValueConverter 
{ 

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     if (value != null) 
     { 
      string imageUrl = value.ToString(); 

      if (imageUrl.Contains("NoImageIcon")) 
       return value; 

      if (imageUrl.Contains(Constants.IMAGES_FOLDER_PATH)) 
      { 
       BitmapImage image = new BitmapImage(); 
       image.CreateOptions = BitmapCreateOptions.BackgroundCreation; 

       IsolatedStorageFile myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication(); 

       if (!myIsolatedStorage.FileExists(imageUrl)) return null; 

       using (myIsolatedStorage) 
       { 
        using (IsolatedStorageFileStream fileStream = myIsolatedStorage.OpenFile(imageUrl, FileMode.Open, FileAccess.Read)) 
        { 
         image.SetSource(fileStream); 
        } 
       } 
       return image; 
      } 

      if (imageUrl.Contains("mp4")) 
      { 
       BitmapImage image = new BitmapImage(new Uri("/Images/video.png", UriKind.Relative)); 
       image.CreateOptions = BitmapCreateOptions.BackgroundCreation; 
       return image; 
      } 

      if (MCSManager.Instance.isInternetConnectionAvailable) 
       return value; 
      else 
      { 
       BitmapImage image = new BitmapImage(new Uri("/Images/defaultImage.png", UriKind.Relative)); 
       image.CreateOptions = BitmapCreateOptions.BackgroundCreation; 
       return image; 
      } 


     } 
     return new Uri("/Images/defaultImage.png", UriKind.Relative); 

    } 

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

} 

Windows 10 Кодекса

public class ImageConverter:IValueConverter 
{ 
    StorageFolder localFolder = ApplicationData.Current.LocalFolder; 
    public object Convert(object value, Type targetType, object parameter, string culture) 
    { 
     if (value != null) 
     { 
      string imageUrl = value.ToString(); 

      if (imageUrl.Contains("NoImageIcon")) 
       return value; 

      if (imageUrl.Contains(Constants.IMAGES_FOLDER_PATH)) 
      { 
       BitmapImage image = new BitmapImage(); 
       image.CreateOptions = BitmapCreateOptions.IgnoreImageCache; 
       System.Threading.Tasks.Task.Factory.StartNew(async()=> 
        { 
         StorageFile imagefile = await localFolder.GetFileAsync(imageUrl); 
         using (IRandomAccessStream fileStream=await imagefile.OpenAsync(FileAccessMode.ReadWrite)) 
         { 

          image.SetSource(fileStream); 
          return image; 
         } 
        }); 
      } 

      if (imageUrl.Contains("mp4")) 
      { 
       BitmapImage image = new BitmapImage(new Uri("ms-appx:///Images/video.png", UriKind.RelativeOrAbsolute)); 
       image.CreateOptions = BitmapCreateOptions.IgnoreImageCache; 
       return image; 
      } 

      if (MCSManager.Instance.isInternetConnectionAvailable) 
       return value; 
      else 
      { 
       BitmapImage image = new BitmapImage(new Uri("ms-appx:///Images/defaultImage.png", UriKind.RelativeOrAbsolute)); 
       image.CreateOptions = BitmapCreateOptions.IgnoreImageCache; 
       return image; 
      } 


     } 
     return new Uri("ms-appx:///Images/defaultImage.png", UriKind.RelativeOrAbsolute); 

    } 
    public object ConvertBack(object value, Type targetType, object parameter, string culture) 
    { 
     return null; 
    } 


    private async Task<bool> FileExists(string fileName) 
    { 
     try 
     { 
      StorageFile file =await localFolder.GetFileAsync(fileName); 
      return true; 
     } 
     catch(FileNotFoundException ex) 
     { 
      return false; 
     } 
    } 
} 

Я хочу использовать этот конвертер в моем ListView DataTemplate. Моя DataTemplate является

<DataTemplate x:Key="NEWReportEvidenceListItemTemplate"> 
    <UserControl> 
     <Grid> 
      <VisualStateManager.VisualStateGroups> 
       <VisualStateGroup> 
        <VisualState> 
         <VisualState.StateTriggers> 
          <AdaptiveTrigger MinWindowWidth="0"/> 
         </VisualState.StateTriggers> 
         <VisualState.Setters> 
          <Setter Target="DFImage.Width" Value="70"/> 
          <Setter Target="DFImage.Height" Value="70"/> 
         </VisualState.Setters> 
        </VisualState> 

        <VisualState> 
         <VisualState.StateTriggers> 
          <AdaptiveTrigger MinWindowWidth="720"/> 
         </VisualState.StateTriggers> 
         <VisualState.Setters> 
          <Setter Target="DFImage.Width" Value="108"/> 
          <Setter Target="DFImage.Height" Value="108"/> 
         </VisualState.Setters> 
        </VisualState> 
       </VisualStateGroup> 
      </VisualStateManager.VisualStateGroups> 
      <Image DataContext="{Binding EvidencePath,Converter={StaticResource ImageConverter}}" 
        Source="{Binding Result}" 
        x:Name="DFImage" 
        Margin="4,0,0,0" 
        Stretch="Uniform"/> 
     </Grid> 
    </UserControl> 
</DataTemplate> 

Answer 1

Используйте это связывание

<Image DataContext="{Binding ImageUrl, Converter={StaticResource ImageConverter}}" Stretch="Uniform" 
      Source="{Binding Result}" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/> 

конвертер класс

public class ImageConverter : IValueConverter 
{ 
    StorageFolder localFolder = ApplicationData.Current.LocalFolder; 
    public object Convert(object value, Type targetType, object parameter, string culture) 
    { 
     if (value != null) 
     { 
      string imageUrl = value.ToString(); 

      if (imageUrl.Contains("NoImageIcon")) 
       return value; 

      if (imageUrl.Contains(Constants.IMAGES_FOLDER_PATH)) 
      { 
       var task = Task.Run(()=>((GetImage((String)value)))); 
       return new TaskCompletionNotifier<BitmapImage>(task); 

      } 

      if (imageUrl.Contains("mp4")) 
      { 
       return new TaskCompletionNotifier<BitmapImage>(Task.Run(() => ((GetImage("ms-appx:///Images/video.png"))))); 


      } 

      if (MCSManager.Instance.isInternetConnectionAvailable) 
      { 
       return new TaskCompletionNotifier<BitmapImage>(Task.Run(() => ((GetImage(value.ToString(),true))))); 
      } 
      else 
      { 
       var task = Task.Run(() => ((GetImage("ms-appx:///Images/defaultImage.png")))); 
       return new TaskCompletionNotifier<BitmapImage>(task); 
      } 


     } 
     return new Uri("ms-appx:///Images/defaultImage.png", UriKind.RelativeOrAbsolute); 

    } 
    private async Task<BitmapImage> GetImage(string path,bool link=false) 
    { 
     BitmapImage image=null; 
     var dispatcher = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher; 
     try 
     { 

      await dispatcher.RunAsync(CoreDispatcherPriority.Normal,async() => 
      { 
       if (link) 
       { 
        image = new BitmapImage(); 
        image.UriSource = new Uri(path, UriKind.RelativeOrAbsolute); 

       } 
       else 
       { 
        image = new BitmapImage(); 
        image.CreateOptions = BitmapCreateOptions.IgnoreImageCache; 

        StorageFile imagefile = await localFolder.GetFileAsync(path); 
        using (IRandomAccessStream fileStream = await imagefile.OpenAsync(FileAccessMode.ReadWrite)) 
        { 

         image.SetSource(fileStream); 

        } 
       } 
      }); 
      return image; 
     } 
     catch(Exception e) 
     { 
      return null; 
     } 


    } 
    public object ConvertBack(object value, Type targetType, object parameter, string culture) 
    { 
     return null; 
    } 


    private async Task<bool> FileExists(string fileName) 
    { 
     try 
     { 
      StorageFile file = await localFolder.GetFileAsync(fileName); 
      return true; 
     } 
     catch (FileNotFoundException ex) 
     { 
      return false; 
     } 
    } 
} 
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; } 



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


    public event PropertyChangedEventHandler PropertyChanged; 
} 

Я возвращаю задачу из конвертера и установить его в DataContext изображения. Задача имеет Result свойство, что я привязывая его к Source собственности

Referred from this link