Wie erstellt man einen Konverter, der async verwendet und in Windows 10 wartet?

Question

Ich migriere meine Windows Phone 8 ImageConverter zu Windows 10, aber ich habe Probleme mit Storage APIs, da es Async verwendet und warten. Kann jemand vorschlagen, was verwendet werden kann, um meine Anforderung zu erfüllen?

Mein Windows Phone 8-Bildwandler-Klasse ist unter

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-Code

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

ich diesen Konverter in meinem Listview Datatemplate verwendet werden soll. My Datatemplate ist

<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

Mit dieser Bindung

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

Converter Klasse

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

Ich bin Aufgabe von Wandler zurückkehrt und es DataContext der Bildeinstellung. Aufgabe hat Result Eigenschaft, dass ich es Source Eigenschaft

Referred from this link