Isolated Storage

While .config files are good for read-only application settings, for read/write user settings, .NET provides isolated storage. It's called isolated because it doesn't require the application to know where on the hard drive the settings files are stored. In fact, the path to the root of the path on the file system isn’t even available to the application. Instead, named chunks of data are called streams and containers of streams and sub-containers are called stores. The model is such that the implementation could vary over time, although currently it’s implemented on top of special folders with sub-folders and files.

The special folder you get depends on the scope you specify when getting the store you want to work with. The scope is specified by combining one or more flags from the IsolatedStorageScope enumeration:

enum IsolatedStorageScope {

  Assembly, // Always required

  Domain,

  None,

  Roaming,

  User, // Always required

}

Isolated storage stores must at least be scoped by assembly and user, which means that there are no user-neutral application settings available from isolated storage, just user and roaming user settings (depending on whether the Roaming flag is used or not). In addition, settings can be scoped to a .NET AppDomain using the Domain flag, but that’s not typically useful in a WinForms application. The valid combinations of scope flags as related to settings localities and example folder roots under Windows XP are shown in Table 1.

IsolatedStorageScope Flags	Locality	Folder Root
Assembly, User	User	C:\Documents and Settings\csells\Local Settings\Application Data\IsolatedStorage
Assembly, User, Roaming	Roaming User	C:\Documents and Settings\csells\Application Data\IsolatedStorage
Assembly, User, Domain	Domain	C:\Documents and Settings\csells\Local Settings\Application Data\IsolatedStorage
Assembly, User, Domain, Roaming	Roaming User Domain	C:\Documents and Settings\csells\Local Settings\Application Data\IsolatedStorage

Table 1: Isolated storage scope, locality and folder roots

Obtaining a store to work with is a matter of specifying the scope to the GetStore method of the IsolatedStorageFile class from the System.IO.IsolatedStorage namespace:

IsolatedStorageScope scope =

  IsolatedStorageScope.Assembly |

  IsolatedStorageScope.User;

IsolatedStorageFile store =

  IsolatedStorageFile.GetStore(scope, null, null);

Because getting the user store for the assembly is so common, the IsolatedStorageFile class provides a helper with that scope already in place:

// Scope = User | Assembly

IsolatedStorageFile store =

  IsolatedStorageFile.GetUserStoreForAssembly();

Once you’ve got the store, you can treat it like a container of streams and sub-containers using the members of the IsolatedStorageFile class:

sealed class IsolatedStorageFile : IsolatedStorage, IDisposable {

  // Properties

  public object AssemblyIdentity { get; }

  public UInt64 CurrentSize { virtual get; }

  public object DomainIdentity { get; }

  public UInt64 MaximumSize { virtual get; }

  public IsolatedStorageScope Scope { get; }

  // Methods

  public void Close();

  public void CreateDirectory(string dir);

  public void DeleteDirectory(string dir);

  public void DeleteFile(string file);

  public string[] GetDirectoryNames(string searchPattern);

  public static IEnumerator GetEnumerator(IsolatedStorageScope scope);

  public string[] GetFileNames(string searchPattern);

  public static IsolatedStorageFile GetStore(...);

  public static IsolatedStorageFile GetUserStoreForAssembly();

  public static IsolatedStorageFile GetUserStoreForDomain();

  public virtual void Remove();

  public static void Remove(IsolatedStorageScope scope);

}

Don't be confused that the IsolatedStorageFile class is actually implemented as a directory the file system. This is but one implementation of the IsolatedStorageStorage abstract base class on the underlying OS's file system. Other implementations are certainly possible (although none are currently provided by .NET).

The most common thing you'll want to do with a store is to create a stream on it using an instance of the IsolatedStorageFileStream. The IsolatedStorageFileStream class is just another implementation of the virtual methods of the FileStream to hide the details of the underlying implementation. Once you've got the stream, you can write to it or read from it just as if you'd opened it as a file yourself. Here's the code to store the main form's location using isolated storage:

void MainForm_Closing(object sender, CancelEventArgs e) {

  // Save the form's position before it closes

  IsolatedStorageFile store =

    IsolatedStorageFile.GetUserStoreForAssembly();

  using( IsolatedStorageFileStream stream =

            new IsolatedStorageFileStream("MainForm.txt",

            FileMode.Create,

            store) )

  using( StreamWriter writer = new StreamWriter(stream) ) {

    // Restore the window state to save location and

    // client size at restored state

    FormWindowState state = this.WindowState;

    this.WindowState = FormWindowState.Normal;