Question

Just a quick question. In WP7, is it really bad design/idea to store complex data using IsolatedStorageSettings.ApplicationSettings? I want to save a collection of some class objects. The properties are marked with [DataMember] attributes.

An example of a class would be,

[DataContract]
public class OfflineItem
{
    [DataMember]
    public string Id { get; set; }
    [DataMember]
    public MyItem Item { get; set; }       
    [DataMember]
    public Dictionary<string, string> KeyValues { get; set; }        
}
Collection<OfflineItems> offlineItems = new Collection<OfflineItems>();
.....
IsolatedStorageSettings.ApplicationSettings["AllOfflineItems"] = offlineItems;

I tried it and it worked, but I want to know if it is a correct approach and will there be any performance hit in the long run?

Answer 1

@Jonna. I deliberated over this one too. I ended up using/adapating the following generic methods to serialize and deserialize using a IsolatedStorageFile as below. It includes deleting a file if it already exists as you are trying to update the data.

    internal static void Write<T>(T obj, string fileName)
    {
        XmlWriterSettings writerSettings = new XmlWriterSettings
        {
            Indent = true,
            IndentChars = "\t"
        };

        try
        {
            using (var isoStore = IsolatedStorageFile.GetUserStoreForApplication())
            {
                if (isoStore.FileExists(fileName))
                {
                    isoStore.DeleteFile(fileName);
                }
                using (var isoStream = new IsolatedStorageFileStream(fileName, FileMode.Create, isoStore))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));

                    using (XmlWriter xmlWriter = XmlWriter.Create(isoStream, writerSettings))
                    {
                        serializer.Serialize(xmlWriter, obj);
                    }
                }
            }
        }
        catch (IsolatedStorageException ex)
        {
            Debug.WriteLine(ex.Message);
        }
        catch (Exception emAll)
        {
            Debug.WriteLine(emAll.Message);
        }
    }

    internal static T Read<T>(string fileName)
    {
        try
        {
            using (var isoStore = IsolatedStorageFile.GetUserStoreForApplication())
            {
                using (var isoStream = new IsolatedStorageFileStream(fileName, FileMode.Open, isoStore))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));
                    return (T)serializer.Deserialize(isoStream);
                }
            }
        }
        catch (IsolatedStorageException ex)
        {
            Debug.WriteLine(ex.Message);
            throw;
        }
        catch (Exception emAll)
        {
            Debug.WriteLine(emAll.Message);
            throw;
        }
    } 

Serialization would be called thus:

Serialization.Write<user>(userDetails, App.USERDETAILS);

And deserialization would be called thus:

Items = Serialization.Read<measurements>(App.MEASUREMENTS);

user is a class and userDetails is an object based on the that class. Measurements is a class and Items is an object based on that class. App.USERDETAILS & App.MEASUREMENTS are global strings that contain file names.

Some debug lines have been left in just so progress can be tracked.

It might also be worth considering using SQL + LINQ if you are thinking of migrating to Mango and much of this could be taken care of there…