1. Locate the ViewDidLoad method in the MyTunesViewController.cs.
2. Comment out the existing TableView.Source assignment.
3. Load the data using SongLoader.Load. This method uses the Task based Async pattern; you will need to await the call and decorate ViewDidLoad with the async keyword.
4. Call ToList on the IEnumerable<Song> returned from SongLoader.Load - we'll use this in the next step. (This will require the System.Linq namespace.)
5. Create a new ViewControllerSource<Song> and assign the following properties:
6. DataSource to the List from the previous step.
7. TextProc to a lambda that returns the name of a song: s => s.Name.
8. DetailTextProc to a lambda that returns the artist and album: s => s.Artist + " - " + s.Album.
9. Assign the ViewControllerSource to TableView.Source.

using System.Linq;
...
public async override void ViewDidLoad()
{
    base.ViewDidLoad();

    //TableView.Source = new ViewControllerSource<string>(TableView) {
    //    DataSource = new string[] { "One", "Two", "Three" },
    //};

    // Load the data
    var data = await SongLoader.Load();

    // Register the TableView's data source
    TableView.Source = new ViewControllerSource<Song>(TableView)
    {
        DataSource = data.ToList(),
        TextProc = s => s.Name,
        DetailTextProc = s => s.Artist + " - " + s.Album,
    };
}

1. Locate the OnCreate method in MainActivity.cs.
2. Comment out the existing ListAdapter assignment.
3. Load the data using SongLoader.Load. This method uses the Task based Async pattern; you will need to await the call and decorate OnCreate with the async keyword.
4. Call ToList on the IEnumerable<Song> returned from SongLoader.Load - we'll use this in the next step. (This will require the System.Linq namespace.)
5. Create a new ListAdapter<Song> and assign the following properties:
6. Set the DataSource property to your new list.
7. Set the TextProc to a lambda that returns the song name: s => s.Name.
8. Set the DetailTextProc to a lambda that returns the artist and album: s => s.Artist + " - " + s.Album.
9. Assign the object to the ListAdapter property.

using System.Linq;
...
protected async override void OnCreate(Bundle bundle)
{
    base.OnCreate(bundle);

    //ListAdapter = new ListAdapter<string>() {
    //    DataSource = new[] { "One", "Two", "Three" }
    //};

    var data = await SongLoader.Load();

    ListAdapter = new ListAdapter<Song>()
    {
        DataSource = data.ToList(),
        TextProc = s => s.Name,
        DetailTextProc = s => s.Artist + " - " + s.Album
    };
}

1. Locate the OnNavigatedTo method in the MainPage.xaml.cs.
2. Comment out the existing this.DataContext assignment and tempData variable.
3. Load the data using SongLoader.Load. This method uses the Task based Async pattern; you will need to await the call and decorate OnNavigatedTo with the async keyword.
4. Call ToList on the IEnumerable<Song> returned from SongLoader.Load - we'll use this in the next step. (This will require the System.Linq namespace.)
5. Assign the resulting list to the DataContext property.

There is already a DataTemplate setup to display the song data.

protected override async void OnNavigatedTo(NavigationEventArgs e)
{
    //var tempData = Enumerable.Range(1, 3).Select(i =>
    //{
    //    return new
    //    {
    //        Name = "Song" + i,
    //        Artist = "Artist" + i,
    //        Album = "Album" + i
    //    };
    //}).ToList();

    // this.DataContext = tempData;

    var data = await SongLoader.Load();

    DataContext = data.ToList();
}

1. In the OpenData method, add a compiler directive for iOS; The Xamarin.iOS compiler defines __IOS__ for this purpose. (If you are doing multiple platforms, use can use elif for "else if" on subsequent conditional blocks.)
2. In your conditional code block, use the System.IO.File.OpenRead method to open the file using the const string FileName.
3. Make sure the iOS project builds.

private static Stream OpenData()
{
#if __IOS__
    return File.OpenRead(Filename);
#else
   // TODO: add code to open file here.
    return null;
#endif
}

1. Add a conditional marker for the Android code; Xamarin.Android defines the __ANDROID__ symbol for this. (If you are doing multiple platforms, use can use elif for "else if" on subsequent conditional blocks.)
2. In your conditional code block, use the Android.App.Application.Context.Assets.Open method to open the filename.
3. Make sure the Android project builds.

private static Stream OpenData()
{
#if __ANDROID__
    return Android.App.Application.Context.Assets.Open(Filename);
#else
   // TODO: add code to open file here.
    return null;
#endif
}

1. Add a conditional marker for Windows; Microsoft defines WINDOWS_UWP. (If you are doing multiple platforms, use can use elif for "else if" on subsequent conditional blocks.)
2. In your conditional code blocks, use the Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync method to open the filename. This returns a StorageFile.
3. Call OpenStreamForReadAsync on the StorageFile to retrieve a Stream.
4. Because UWP APIs are frequently async, you will need to change the method signature to be async and use the await keyword - the calling code will also need to be adjusted for this.
5. The code for the other platforms can remain the same - however you will get a compiler warning because the method is decorated with async but doesn't contain any awaited calls for iOS and Android. You can ignore these warnings.
6. Make sure the Windows project builds.

public static async Task<IEnumerable<Song>> Load()
{
    using (var reader = new StreamReader(await OpenData())) {
        return JsonConvert.DeserializeObject<List<Song>>(
                await reader.ReadToEndAsync());
    }
}

private async static Task<Stream> OpenData()
{
#if WINDOWS_UWP
   var sf = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(Filename);
   return await sf.OpenStreamForReadAsync();
#else
   // TODO: add code to open file here.
   return null;
#endif
}