Question

I have created an app that initially creates a database and saves some data in it.
Now I want to delete this database and its files when the user clicks on the reset button but I am getting an error – ‘this is use in another process’. I want it to delete and recreate the database when click on the reset button. Any ideas?

Answer 1

The most frequent cause of this is ude to the thread unsafe nature of interacting with isolated storage on Windows Phone. Regardless of how you’re implementing the database (be it in a file, or series of files), you’re interacting with the isolated storage on some level.

I highly encourage you to read, and make sure you understand this overview of isolated storage before going too far.

You’re remark:

This is in use in another process

makes me think you’re using a third party library to do your database stuff. This exception/error is being thrown when the library itsself is unable to access isolated storage. Without knowing exactly how you’re implementing the database, it’s hard to be exactly speak to your situation.

You never “recreate IsolatedStorage”, Isolated Storage is a term used to define the collection of disk space your application has access to. Much like a folder, this disk space has a root, and contains only files that you create.

In order to avoid thread exceptions when accessing Isolated Storage, make sure you use the using keyword in C# like so:

namespace IsolatedStorageExample
{
    public class ISOAccess
    {
        // This example method will read a file inside your Isolated Storage.
        public static String ReadFile(string filename)
        {
            string fileContents = "";
            // Ideally, you should enclose this entire next section in a try/catch block since
            // if there is anything wrong with below, it will crash your app.
            // 
            // This line returns the "handle" to your Isolated Storage. The phone considers the
            // entire isolated storage folder as a single "file", which is why it can be a 
            // little bit of a confusing name.
            using(IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForAppliaction())
            {   
                // If the file does not exist, return an empty string
                if(file.Exists(filename))
                {
                    // Obtain a stream to the file
                    using(IsolatedStorageFileStream stream = File.OpenFile(filename, FileMode.Open)
                    {
                        // Open a stream reader to actually read the file.
                        using(StreamReader reader = new StreamReader(stream))
                        {
                            fileContents = reader.ReadToEnd();
                        }
                    }
                }   
            }

            return fileContents;
        }
    }
}

That should help with your problem of thread safety. To be more specifically helpful toward what you want to do, take a look at the following methods (you can add this to the above class):

// BE VERY CAREFUL, running this method will delete *all* the files in isolated storage... ALL OF THEM
public static void ClearAllIsolatedStorage()
{
    // get the handle to isolated storage
    using(IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication())
    {
        // Get a list of all the folders in the root directory
        Queue<String> rootFolders = new Queue<String>(file.GetDirectoryNames());

        // For each folder...
        while(0 != rootFolders.Count)
        {
            string folderName = rootFolders.Dequeue();

            // First, recursively delete all the files and folders inside the given folder.
            // This is required, because you cannot delete a non-empty directory
            DeleteFilesInFolderRecursively(file, folderName);

            // Now that all of it's contents have been deleted, you can delete the directory
            // itsself.
            file.DeleteDirectory(rootFolders.Dequeue());
        }

        // And now we delete all the files in the root directory
        Queue<String> rootFiles = new Queue<String>(file.GetFileNames());
        while(0 != rootFiles.Count)
            file.DeleteFile(rootFiles.Dequeue());
    }
}

private static void DeleteFilesInFolderRecursively(IsolatedStorageFile iso, string directory)
{
    // get the folders that are inside this folder
    Queue<string> enclosedDirectories = new Queue<string>(iso.GetDirectoryNames(directory));

    // loop through all the folders inside this folder, and recurse on all of them
    while(0 != enclosedDirectories.Count)
    {
        string nextFolderPath = Path.Combine(directory, enclosedDirectories.Dequeue());
        DeleteFilesInFolderRecursively(nextFolderPath);
    }

    // This string will allow you to see all the files in this folder.
    string fileSearch = Path.Combine(directory, "*");

    // Getting the files in this folder
    Queue<string> filesInDirectory = iso.GetFileNames(fileSearch);

    // Finally, deleting all the files in this folder
    while(0 != filesInDirectory.Count)
    {
        iso.DeleteFile(filesInDirectory.Dequeue());
    }
}

Another thing I highly recommend is implementing the class that accesses IsolatedStorage using a “Multithreaded Singleton Pattern” as described here.

Hope that’s helpful. Code is provided “as-is”, I have not compiled it, but the general concepts are all there, so if there’s something amiss, read the MSDN docs to see where I goofed. But I assure you, most of this is copied from functional code of mine, so it should work properly with very little fanagaling.