To perform operations on the file stored in the isolated storage, you create a new class, named LocalRank, in the .cs file inside the Models directory. The class has two methods, to add a new result, as well as to read top scores. To make maintenance of the class easier, you store the file name (where local results are saved) as the constant value named FILENAME. You also create the private field, which is an instance of the IsolatedStorageFile class. By default, you assign to it an object that represents the storage for the current application, as shown in the following code snippet:

private const string FILENAME = "Rank.txt";
private IsolatedStorageFile m_file = 
  IsolatedStorageFile.GetUserStoreForApplication();

The AddResult method adds information about the player name and the score to the file, as shown as follows:

public void AddResult(string name, int score)
{
  IsolatedStorageFileStream stream = this.m_file.OpenFile(
    FILENAME, FileMode.Append, FileAccess.Write);
  using (StreamWriter writer = new StreamWriter(stream))
  {
    writer.WriteLine("{0};{1}", name, score);
  }
}

At the beginning, you create a new IsolatedStorageFileStream instance representing the stream of the opened file. You specify that you will open the file in the Append mode (content will be added at the end of the file) for writing.

Then, you use the StreamWriter class to write the new content to the stream. You can use the WriteLine method, which puts a specific text followed by a new line.

It is worth mentioning that you use the using statement in the previous code. With it, resources required by the StreamWriter instance are released automatically when the execution exits the using statement. Thus, you can use resources more efficiently.

The ReadTopScores method parses the content of the whole file and returns an array of ten top scores:

public RankItem[] ReadTopScores()
{
  List<RankItem> items = new List<RankItem>();
  IsolatedStorageFileStream stream = this.m_file.OpenFile(
    FILENAME, FileMode.OpenOrCreate, FileAccess.Read);
  using (StreamReader reader = new StreamReader(stream))
  {
    string line;
    while ((line = reader.ReadLine()) != null)
    {
      string[] parts = line.Split(';'),
      RankItem item = new RankItem(-1, parts[0],
        int.Parse(parts[1]));
      items.Add(item);
    }
  }
  items = items.OrderByDescending(i => i.Score).Take(10).ToList();
  for (int i = 0; i < items.Count; i++)
  {
    items[i].Number = i + 1;
  }
  return items.ToArray();
}

Reading the file from the isolated storage is similar to writing. You create a new instance of the IsolatedStorageFileStream and assign to it an object returned by the OpenFile method. However, here you need to choose different values from the FileMode and FileAccess enumerations, because the file should be opened (or created, if does not exist) and you only need to read it. Then, you use the StreamReader class to read data from the file stream.

The single result is stored in a separate line. Thus, you should read all lines and then split each by semicolon to read both the player name and the score. To read the single line, the ReadLine method can be used. To read many lines, you can place this instruction inside the condition of the while loop. The line from the file is stored in the line variable.

To get the player name and the score, you use the Split method. It returns an array of string values representing particular substrings separated by the specific character or string. As an example, if you call the Split method (with a semicolon as a parameter) on the string instance equal to Marcin;10000, the returned array will contain two elements, namely Marcin and 10000.

Next, you create a new instance of the RankItem class and set values of its parameters, using the constructor. Then, you add it to the items collection.

At the end, you sort read data by the score (descending), take first ten elements, and convert them to a list. The for loop is used to set the Number properties of the top scores. The last statement just returns RankItem instances as an array.

The local rank should be presented just after opening the Ranks screen. Thus, you need to slightly modify the view model class for this page. In the OnNavigatedTo method, you create a new instance of the LocalRank class, call the ReadTopScores method, and assign the results to the RankLocal property. By using the data binding mechanism, the user interface will be updated automatically. The suitable part of the code is shown as follows:

public void OnNavigatedTo(NavigationEventArgs e)
{ (...)
  LocalRank localRank = new LocalRank();
  this.RankLocal = localRank.ReadTopScores();
}

Other modifications are required in the Direct3DInterop class from the native part. The aim is to prepare a way of sending the current score to the managed part and indicate that it should be saved locally. You can implement it in a way similar to the one presented earlier, for indicating that the result should be sent to the web service. At the beginning, you add the SaveResultHandler delegate and the SaveResult event:

public delegate void SaveResultHandler(); (...)
event SaveResultHandler^ SaveResult;

Apart from changes in the header file, you will also modify an implementation of the OnPointerReleased method in the Direct3DInterop.cpp file:

void Direct3DInterop::OnPointerReleased(
  DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)
{ (...)
  if (action != SA3D_ACTION_NONE && LastScore > 0) { SaveResult(); }
}

Here, you add the conditional expression at the end of the method. When the current action is other than SA3D_ACTION_NONE and the score is greater than zero, you fire the SaveResult event. It causes that the managed part receives information that the current result should be saved locally.

Next changes required by the local rank mechanism involve the code-behind file regarding the Game screen. In the DrawingSurface_Loaded, you specify the method which is called when the SaveResult event is fired. Here, it is named Interop_SaveResult:

m_d3dInterop.SaveResult += this.Interop_SaveResult;

Inside this method, you just call the SaveResult one from the view model. You get the last score by reading the LastScore property of the m_d3dInterop field:

private void Interop_SaveResult()
{
  this.m_viewModel.SaveResult(this.m_d3dInterop.LastScore);
}

The last modification is necessary in the view model for the Game screen. Here, you implement the SaveResult method. Inside it, you create the new LocalRank instance and call the AddResult method, as presented in the following code:

public void SaveResult(int result)
{
  LocalRank localRank = new LocalRank();
  localRank.AddResult(Settings.Name, result);
}

Currently, you can launch your game, play for some time, navigate to the Ranks screen, and see your scores!