namespace MyBlankApp
{
  using System.Threading.Tasks;
  using Windows.Storage;
  using Windows.UI.Xaml.Media;
  using Windows.UI.Xaml.Media.Imaging;

  using System;
  using System.IO;

  class ImageViewModel : ViewModelBase
  {
    internal ImageSource Image
    {
      get
      {
        return (this.image);
      }
      set
      {
        base.SetProperty(ref this.image, value);
      }
    }
    ImageSource image;

    // public to keep ComboBox.DisplayMemberPath happy.
    public string Title
    {
      get
      {
        return (this.title);
      }
      set
      {
        base.SetProperty(ref this.title, value);
      }
    }
    string title;

    internal async Task PopulateFromFileAsync(StorageFile file)
    {
      var source = new BitmapImage();
      var stream = await file.OpenReadAsync();
      source.SetSource(stream);
      this.Image = source;
      this.Title = Path.GetFileNameWithoutExtension(
        file.Name);
    }
  }
}

namespace MyBlankApp
{
  using System;
  using System.Collections.ObjectModel;
  using System.Threading.Tasks;
  using Windows.ApplicationModel;

  class ImageListViewModel : ViewModelBase
  {
    public ObservableCollection<ImageViewModel> Images
    {
      get
      {
        return (this.images);
      }
      set
      {
        base.SetProperty(ref this.images, value);
      }
    }
    ObservableCollection<ImageViewModel> images;

    public ImageViewModel SelectedImage
    {
      get
      {
        return (this.Images[this.SelectedIndex]);
      }
    }

    public int SelectedIndex
    {
      get
      {
        return (this.selectedIndex);
      }
      set
      {
        base.SetProperty(ref this.selectedIndex, value);
        base.OnPropertyChanged("SelectedImage");
      }
    }
    int selectedIndex;

    internal async Task PopulateFromFolderAsync()
    {
      var assetsFolder = 
        await Package.Current.InstalledLocation.GetFolderAsync("Assets");
      var imagesFolder =
        await assetsFolder.GetFolderAsync("Images");
     
      this.Images = new ObservableCollection<ImageViewModel>();

      var files = await imagesFolder.GetFilesAsync();

      foreach (var file in files)
      {
        var image = new ImageViewModel();

        await image.PopulateFromFileAsync(file);

        this.Images.Add(image);
      }
      this.SelectedIndex = 0;
    }
  }
}

<UserControl
  x:Class="MyBlankApp.MainControl"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:local="using:MyBlankApp"
  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  mc:Ignorable="d"
  d:DesignHeight="300"
  d:DesignWidth="400">

  <Grid>
    <Image
      Source="{x:Bind ViewModel.SelectedImage.Image,Mode=OneWay}"
      Stretch="Uniform" />
    <ComboBox
      ItemsSource="{x:Bind ViewModel.Images,Mode=OneWay}"
      SelectedIndex="{x:Bind ViewModel.SelectedIndex,Mode=TwoWay}"
      DisplayMemberPath="Title"
      VerticalAlignment="Top"
      HorizontalAlignment="Left"      
      Width="132"
      Margin="96">
    </ComboBox>
  </Grid>
</UserControl>

using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using Windows.UI.Xaml.Controls;

namespace MyBlankApp
{
  public sealed partial class MainControl : UserControl,
    INotifyPropertyChanged
  {
    public event PropertyChangedEventHandler PropertyChanged;

    public MainControl()
    {
      this.InitializeComponent();
    }

    internal ImageListViewModel ViewModel
    {
      get
      {
        return (this.viewModel);
      }
      set
      {
        this.SetProperty(ref this.viewModel, value);
      }
    }
    ImageListViewModel viewModel;

    bool SetProperty<T>(ref T storage, T value,
      [CallerMemberName] String propertyName = null)
    {
      if (object.Equals(storage, value)) return false;

      storage = value;
      this.OnPropertyChanged(propertyName);
      return true;
    }
    void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
      this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}

namespace MyBlankApp
{
  using System;
  using System.IO;
  using System.Threading.Tasks;
  using Windows.Storage;

  static class StateManagement
  {
    static internal async Task SaveStateAsync(int state)
    {
      // Our state is simply an integer (the selected image). We could
      // put it into App settings but let's put it into a file to be
      // similar to what a real app would do.
      var stateFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
        stateFileName, CreationCollisionOption.ReplaceExisting);

      await FileIO.WriteTextAsync(stateFile, state.ToString());
    }
    static internal async Task<int> LoadStateAsync()
    {
      var state = 0;

      try
      {
        var stateFile = await ApplicationData.Current.LocalFolder.GetFileAsync(
          stateFileName);

        var contents = await FileIO.ReadTextAsync(stateFile);

        int.TryParse(contents, out state);
      }
      catch (FileNotFoundException)
      {
      }
      return (state);
    }
    const string stateFileName = "statefile.bin";
  }
}

namespace MyBlankApp
{
  using System.Threading.Tasks;
  using Windows.ApplicationModel;
  using Windows.ApplicationModel.Activation;
  using Windows.UI.Xaml;

  sealed partial class App : Application
  {
    public App()
    {
      this.InitializeComponent();
      this.Suspending += OnSuspending;
    }
    protected async override void OnLaunched(LaunchActivatedEventArgs args)
    {
      int? selectedIndex = null;

      if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
      {
        selectedIndex = await StateManagement.LoadStateAsync();
      }
      await this.LoadViewModelAsync(selectedIndex);

      this.EnsureUI();
    }
    async Task LoadViewModelAsync(int? selectedIndex)
    {
      if (this.viewModel == null)
      {
        this.viewModel = new ImageListViewModel();
        await this.viewModel.PopulateFromFolderAsync();
      }
      if (selectedIndex.HasValue)
      {
        this.viewModel.SelectedIndex = (int)selectedIndex;
      }
    }
    void EnsureUI()
    {
      if (Window.Current.Content == null)
      {
        var ui = new MainControl();
        ui.ViewModel = this.viewModel;

        Window.Current.Content = ui;
      }
      Window.Current.Activate();
    }
    async void OnSuspending(object sender, SuspendingEventArgs e)
    {
      var deferral = e.SuspendingOperation.GetDeferral();

      await StateManagement.SaveStateAsync(this.viewModel.SelectedIndex);

      deferral.Complete();
    }
    ImageListViewModel viewModel;
  }
}

namespace MyBlankApp
{
  using System.Collections.Generic;
  using System.Threading.Tasks;
  using Windows.UI.StartScreen;
  using System;
  using System.Linq;

  internal class StateBag<T>
  {
    internal StateBag()
    {
      this.state = new Dictionary<string, T>();
    }
    internal T GetStateForInstance(string instanceId)
    {
      T stateValue = default(T);
      this.state.TryGetValue(instanceId, out stateValue);
      return (stateValue);
    }
    internal void SetStateForInstance(string instanceId, T state)
    {
      this.state[instanceId] = state;
    }
    internal async Task TidyOldInstancesAsync()
    {
      var secondaryTiles = await SecondaryTile.FindAllAsync();

      var orphanedKeys = state.Keys.Except(secondaryTiles.Select(s => s.TileId)).ToArray();

      foreach (var key in orphanedKeys)
      {
        state.Remove(key);
      }
    }
    Dictionary<string, T> state;
  }
}

namespace MyBlankApp
{
  using Newtonsoft.Json;
  using Newtonsoft.Json.Serialization;
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using System.Reflection;
  using System.Threading.Tasks;
  using Windows.Storage;

  static class StateManagement
  {
    class PrivateContractResolver : DefaultContractResolver
    {
      protected override List<MemberInfo> GetSerializableMembers(Type objectType)
      {
        var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
        MemberInfo[] fields = objectType.GetFields(flags);
        return fields
            .Concat(objectType.GetProperties(flags).Where(propInfo => propInfo.CanWrite))
            .ToList();
      }

      protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
      {
        return base.CreateProperties(type, MemberSerialization.Fields);
      }
    }
    static StateManagement()
    {
      jsonSerializerSettings = new JsonSerializerSettings()
      {
        ContractResolver = new PrivateContractResolver()
      };
    }
    static internal async Task SaveStateAsync<T>(StateBag<T> state)
    {
      // Our state is simply an integer (the selected image). We could
      // put it into App settings but let's put it into a file to be
      // similar to what a real app would do.
      var stateFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
        stateFileName, CreationCollisionOption.ReplaceExisting);

      var json = JsonConvert.SerializeObject(state, jsonSerializerSettings);

      await FileIO.WriteTextAsync(stateFile, json);
    }
    static internal async Task<StateBag<T>> LoadStateAsync<T>()
    {
      StateBag<T> state = null;

      try
      {
        var stateFile = await ApplicationData.Current.LocalFolder.GetFileAsync(
          stateFileName);

        var contents = await FileIO.ReadTextAsync(stateFile);

        state = JsonConvert.DeserializeObject<StateBag<T>>(
          contents, jsonSerializerSettings);
      }
      catch (FileNotFoundException)
      {
      }
      return (state);
    }
    static JsonSerializerSettings jsonSerializerSettings;
    const string stateFileName = "statefile.bin";
  }
}

namespace MyBlankApp
{
  using System.Threading.Tasks;
  using Windows.ApplicationModel;
  using Windows.ApplicationModel.Activation;
  using Windows.UI.Xaml;

  sealed partial class App : Application
  {
    public App()
    {
      this.InitializeComponent();
      this.state = new StateBag<int>();
      this.Suspending += OnSuspending;
    }
    protected async override void OnLaunched(LaunchActivatedEventArgs args)
    {
      if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
      {
        this.state = await StateManagement.LoadStateAsync<int>();
      }

      // If we've already been launched, make sure we record the selected index
      // for that tile ID because we can be launched->launched->launched
      // without necessarily suspending. 
      if (!string.IsNullOrEmpty(this.currentTileId))
      {
        this.state.SetStateForInstance(this.currentTileId, this.viewModel.SelectedIndex);
      }
      // Note the last tile that launched.
      this.currentTileId = args.TileId;

      var selectedIndex = this.state.GetStateForInstance(this.currentTileId);

      await this.LoadViewModelAsync(selectedIndex);

      this.EnsureUI();
    }
    async Task LoadViewModelAsync(int selectedIndex)
    {
      if (this.viewModel == null)
      {
        this.viewModel = new ImageListViewModel();
        await this.viewModel.PopulateFromFolderAsync();
      }
      this.viewModel.SelectedIndex = selectedIndex;
    }
    void EnsureUI()
    {
      if (Window.Current.Content == null)
      {
        var ui = new MainControl();
        ui.ViewModel = this.viewModel;

        Window.Current.Content = ui;
      }
      Window.Current.Activate();
    }
    async void OnSuspending(object sender, SuspendingEventArgs e)
    {
      var deferral = e.SuspendingOperation.GetDeferral();

      this.state.SetStateForInstance(this.currentTileId,
        this.viewModel.SelectedIndex);

      await StateManagement.SaveStateAsync<int>(this.state);

      deferral.Complete();
    }
    string currentTileId;
    StateBag<int> state;
    ImageListViewModel viewModel;
  }
}