×
Namespaces

Variants
Actions
(Difference between revisions)

Introduction and best practices for IsolatedStorageSettings

From Nokia Developer Wiki
Jump to: navigation, search
hamishwillee (Talk | contribs)
m (Hamishwillee - Bot update - Fix metadata)
jinek (Talk | contribs)
(Jinek -)
Line 1: Line 1:
[[Category:Draft]]
+
[[Category:Code Examples]][[Category:Windows Phone]][[Category:Silverlight]][[Category:Files/Data]]
 
{{Abstract|This article explains how to work with IsolatedStorageSettings.}}
 
{{Abstract|This article explains how to work with IsolatedStorageSettings.}}
 
{{ArticleMetaData <!-- v1.2 -->
 
{{ArticleMetaData <!-- v1.2 -->
Line 25: Line 25:
  
 
== Introduction ==
 
== Introduction ==
[http://msdn.microsoft.com/en-us/library/system.io.isolatedstorage.isolatedstoragesettings(v=vs.95).aspx IsolatedStorageSettings] - is dictionary-like way for permanent storing values in  [http://msdn.microsoft.com/en-us/library/x7dzh4ws(v=vs.95).aspx Isolated Storage]. All that you have to do to store a value - is provide a key for this value and a value itself.
+
[http://msdn.microsoft.com/en-us/library/system.io.isolatedstorage.isolatedstoragesettings(v=vs.95).aspx IsolatedStorageSettings] - is a dictionary for permanent storing values in  [http://msdn.microsoft.com/en-us/library/x7dzh4ws(v=vs.95).aspx Isolated Storage]. All that you have to do to store a value - is to provide a key for this value and a value itself.
You can store anything you want: user settings, layout information or application state. All settings from IsolatedStorageSettings are accessible after application shutdown and run again.
+
You can store anything you want that is serializable, for example: user settings, layout information or application state. All settings from IsolatedStorageSettings are accessible after application shutdown and run again.
In this tutorial we are going to create a simple application that keeps one boolean value and then we will extend it for more convenient use.
+
In this tutorial we will create a simple application that keeps one boolean value and then we are going to extend it for more convenient use.
 
== Basic Sample ==
 
== Basic Sample ==
 
# Run Visual Studio 2012
 
# Run Visual Studio 2012
Line 44: Line 44:
 
               VerticalAlignment="Top" />
 
               VerticalAlignment="Top" />
 
</phone:PhoneApplicationPage></code>
 
</phone:PhoneApplicationPage></code>
#Navigate to MainPage.xaml.cs and add code that does the actual work:<code csharp>using System.IO.IsolatedStorage;
+
#Navigate to MainPage.xaml.cs and insert code for storing and retrieving the value:<code csharp>using System.IO.IsolatedStorage;
 
using System.Windows;
 
using System.Windows;
  
Line 98: Line 98:
 
}</code>
 
}</code>
 
#Run the application
 
#Run the application
You might see the checkbox which after launch can remember his last state before application shutdown.
+
As expected - checkbox remembers last state before application shutdown.
 
<gallery>
 
<gallery>
 
File:IsolatedStorageIntro.SimpleApplication.png|Simple setting
 
File:IsolatedStorageIntro.SimpleApplication.png|Simple setting
 
</gallery>
 
</gallery>
IsolatedStorageSettings is easy to use. But if you are going to have more then just one setting-value - syncing, keeping key name, checking if setting exists and saving each time it been updated may become a headache. Better way is to implement all this functionality in helper class only once.
+
IsolatedStorageSettings is easy to use. But if you are going to have more then just one setting-value - syncing, keeping key name, checking if setting exists and saving each time it has been updated may become a headache. Better way is to implement all this functionality in a helper class only once.
 
== Improvement ==
 
== Improvement ==
Easier way to work with IsolatedStorageSettings is to create a wrapper class around it. It would save the setting every time we update it (in a thread safe maner), it would automatically set default value if setting does not exist and finally it would keep the key name - we have to provide it only once during property declaration.
+
Now we are going to create new class and implement logic for storing and retrieving in it: it should save the setting every time we update it (in a thread safe maner), it should automatically set the default value if setting does not exist and finally it should keep the key name - we have to provide it only once at property declaration.
 
Create two new classes:
 
Create two new classes:
 
<code csharp>using System.IO.IsolatedStorage;
 
<code csharp>using System.IO.IsolatedStorage;
Line 190: Line 190:
 
}</code>
 
}</code>
 
You can extend this classes as you want (may be you want to save values only when application is shutting down?) or you can just copy this classes to your project and start working right now.
 
You can extend this classes as you want (may be you want to save values only when application is shutting down?) or you can just copy this classes to your project and start working right now.
Using this class is easier then IsolatedStorageSettings:
+
Using IsolatedStorageProperty class is easier then IsolatedStorageSettings:
 
<code csharp>namespace IsolatedStorageSample
 
<code csharp>namespace IsolatedStorageSample
 
{
 
{
Line 216: Line 216:
 
     }
 
     }
 
}</code>
 
}</code>
See? We still have only one setting but a lot of lines are gone! - With ten or more property-settings this class become indispensable.
+
We still have only one setting but a lot of lines are gone! - With ten or more property-settings this class become indispensable.
 
Lets create another setting - FirstRunTimeProperty:
 
Lets create another setting - FirstRunTimeProperty:
 
<code csharp>using System;
 
<code csharp>using System;
Line 266: Line 266:
  
 
Good practice is to create a special static class, that would contain all your settings in it, so you can access any property in a program
 
Good practice is to create a special static class, that would contain all your settings in it, so you can access any property in a program
at any time you want:
+
at any time:
 
<code csharp>namespace IsolatedStorageSample
 
<code csharp>namespace IsolatedStorageSample
 
{
 
{
Line 278: Line 278:
 
     }
 
     }
 
}</code>
 
}</code>
''The "platform categories" will be displayed here in '''preview''' only - Copy paste relevant categories into text here''
 
 
{{VersionHint|Versions will be visible from this template when viewed in preview. You can delete this or leave it in the page as it is not displayed in final version}}
 
[[Category:Code Examples]]
 

Revision as of 10:29, 13 November 2012

This article explains how to work with IsolatedStorageSettings.

WP Metro Icon File.png
SignpostIcon XAML 40.png
WP Metro Icon WP8.png
SignpostIcon WP7 70px.png
Article Metadata
Code ExampleTested with
SDK: [1]
Compatibility
Platform(s): Windows Phone 7.5 and 8.0
Windows Phone 8
Windows Phone 7.5
Article
Keywords: IsolatedStorageSettings, Isolated Storage, User Settings-->
Created: jinek (09 Nov 2012)
Last edited: jinek (13 Nov 2012)

Introduction

IsolatedStorageSettings - is a dictionary for permanent storing values in Isolated Storage. All that you have to do to store a value - is to provide a key for this value and a value itself. You can store anything you want that is serializable, for example: user settings, layout information or application state. All settings from IsolatedStorageSettings are accessible after application shutdown and run again. In this tutorial we will create a simple application that keeps one boolean value and then we are going to extend it for more convenient use.

Basic Sample

  1. Run Visual Studio 2012
  2. Create new Windows Phone project (7.5 or 8.0)
  3. Navigate to MainPage.xaml and replace all control content with one checkbox:
    <phone:PhoneApplicationPage x:Class="IsolatedStorageSample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}">
    <CheckBox Content="Switch option"
    Name="chck"
    Checked="chck_Checked"
    Unchecked="chck_Unchecked"
    VerticalAlignment="Top" />
    </phone:PhoneApplicationPage>
  4. Navigate to MainPage.xaml.cs and insert code for storing and retrieving the value:
    using System.IO.IsolatedStorage;
    using System.Windows;
     
    namespace IsolatedStorageSample
    {
    public partial class MainPage
    {
    /// <summary>
    /// Object for sync access to IsolatedStorage
    /// </summary>
    private readonly object _sync = new object();
     
    private const string SwitchKeyName = "switch";
     
    // Constructor
    public MainPage()
    {
    InitializeComponent();
    //checking if property exists, if no - create it
    if (!IsolatedStorageSettings.ApplicationSettings.Contains(SwitchKeyName))
    {
    IsolatedStorageSettings.ApplicationSettings[SwitchKeyName] = true;
    SaveSettings();
    }
     
    //the checkbox state initializing
    chck.IsChecked = (bool) IsolatedStorageSettings.ApplicationSettings[SwitchKeyName];
    }
     
    private void chck_Checked(object sender, RoutedEventArgs e)
    {
    IsolatedStorageSettings.ApplicationSettings[SwitchKeyName] = true;
    SaveSettings();
    }
     
    private void chck_Unchecked(object sender, RoutedEventArgs e)
    {
    IsolatedStorageSettings.ApplicationSettings[SwitchKeyName] = false;
    SaveSettings();
    }
     
    /// <summary>
    /// Saving settings to isolated storage
    /// </summary>
    private void SaveSettings()
    {
    lock (_sync)
    {
    IsolatedStorageSettings.ApplicationSettings.Save();
    }
    }
    }
    }
  5. Run the application

As expected - checkbox remembers last state before application shutdown.

IsolatedStorageSettings is easy to use. But if you are going to have more then just one setting-value - syncing, keeping key name, checking if setting exists and saving each time it has been updated may become a headache. Better way is to implement all this functionality in a helper class only once.

Improvement

Now we are going to create new class and implement logic for storing and retrieving in it: it should save the setting every time we update it (in a thread safe maner), it should automatically set the default value if setting does not exist and finally it should keep the key name - we have to provide it only once at property declaration. Create two new classes:

using System.IO.IsolatedStorage;
 
namespace IsolatedStorageSample
{
/// <summary>
/// Helper class is needed because IsolatedStorageProperty is generic and
/// can not provide singleton model for static content
/// </summary>
internal static class IsolatedStoragePropertyHelper
{
/// <summary>
/// We must use this object to lock saving settings
/// </summary>
public static readonly object ThreadLocker = new object();
 
public static readonly IsolatedStorageSettings Store = IsolatedStorageSettings.ApplicationSettings;
}
 
/// <summary>
/// This is wrapper class for storing one setting
/// Object of this type must be single
/// </summary>
/// <typeparam name="T">Any serializable type</typeparam>
public class IsolatedStorageProperty<T>
{
private readonly object _defaultValue;
private readonly string _name;
private readonly object _syncObject = new object();
 
public IsolatedStorageProperty(string name, T defaultValue = default(T))
{
_name = name;
_defaultValue = defaultValue;
}
 
/// <summary>
/// Determines if setting exists in the storage
/// </summary>
public bool Exists
{
get { return IsolatedStoragePropertyHelper.Store.Contains(_name); }
}
 
/// <summary>
/// Use this property to access the actual setting value
/// </summary>
public T Value
{
get
{
//If property does not exist - initializing it using default value
if (!Exists)
{
//Initializing only once
lock (_syncObject)
{
if (!Exists) SetDefault();
}
}
 
return (T) IsolatedStoragePropertyHelper.Store[_name];
}
set
{
IsolatedStoragePropertyHelper.Store[_name] = value;
Save();
}
}
 
private static void Save()
{
lock (IsolatedStoragePropertyHelper.ThreadLocker)
{
IsolatedStoragePropertyHelper.Store.Save();
}
}
 
public void SetDefault()
{
Value = (T) _defaultValue;
}
}
}

You can extend this classes as you want (may be you want to save values only when application is shutting down?) or you can just copy this classes to your project and start working right now. Using IsolatedStorageProperty class is easier then IsolatedStorageSettings:

namespace IsolatedStorageSample
{
using System.Windows;
 
public partial class MainPage
{
//Setting declaration
static readonly IsolatedStorageProperty<bool> SwitchProperty = new IsolatedStorageProperty<bool>("switch",true);
 
public MainPage()
{
InitializeComponent();
chck.IsChecked = SwitchProperty.Value;
}
private void chck_Checked(object sender, RoutedEventArgs e)
{
SwitchProperty.Value = true;
}
 
private void chck_Unchecked(object sender, RoutedEventArgs e)
{
SwitchProperty.Value = false;
}
}
}

We still have only one setting but a lot of lines are gone! - With ten or more property-settings this class become indispensable. Lets create another setting - FirstRunTimeProperty:

using System;
 
namespace IsolatedStorageSample
{
using System.Windows;
 
public partial class MainPage
{
static readonly IsolatedStorageProperty<bool> SwitchProperty = new IsolatedStorageProperty<bool>("switch",true);
 
/// <summary>
/// Keeps first run time
/// </summary>
static readonly IsolatedStorageProperty<DateTime> FirstRunTimeProperty = new IsolatedStorageProperty<DateTime>("firstruntime", DateTime.Now);
 
public MainPage()
{
InitializeComponent();
chck.IsChecked = SwitchProperty.Value;
Loaded+=OnLoaded;
}
 
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
//MessageBox.Show - could freeze main thread for a long time
//Dont let it freeze the constructor
MessageBox.Show(FirstRunTimeProperty.Value.ToString());
//This MessageBox always shows time of first run
}
 
private void chck_Checked(object sender, RoutedEventArgs e)
{
SwitchProperty.Value = true;
}
 
private void chck_Unchecked(object sender, RoutedEventArgs e)
{
SwitchProperty.Value = false;
}
}
}

FirstRunTimeProperty let us know when was first application run.

You can run the application two or more times to test it.

Good practice is to create a special static class, that would contain all your settings in it, so you can access any property in a program at any time:

namespace IsolatedStorageSample
{
public static class SettingsContainer
{
public static readonly IsolatedStorageProperty<bool> TestProperty1
= new IsolatedStorageProperty<bool>("TestProperty1");
public static readonly IsolatedStorageProperty<string> TestProperty2
= new IsolatedStorageProperty<string>("TestProperty2", "This is a test property");
//...
}
}
1283 page views in the last 30 days.