This documentation is archived and is not being maintained.

How to: Enumerate Stores for Isolated Storage

You can enumerate all isolated stores for the current user using the IsolatedStorageFile static method GetEnumerator. GetEnumerator takes an IsolatedStorageScope value and returns an IsolatedStorageFile enumerator. User is the only IsolatedStorageScope value supported. To enumerate stores, you must have the IsolatedStorageFilePermission that specifies the IsolatedStorageContainment value AdministerIsolatedStorageByUser. When called with the IsolatedStorageScope value User, GetEnumerator returns an array of IsolatedStorageFiles that are defined for the current user.

The following code example obtains a store isolated by user and assembly and creates a few files. The GetEnumerator method is called and the result is placed into an IEnumerator. The code then loops through the IEnumerator, adding up the sizes of the files, and reports the result to the console. The actual enumeration takes place in the private EnumerateTheStore method that is separated from the rest of the code at the bottom of the file for clarity.


using namespace System;
using namespace System::IO;
using namespace System::IO::IsolatedStorage;
using namespace System::Collections;

public ref class EnumeratingStores
{
public:
    static int Main()
    {
        // Get an isolated store for this assembly and put it into an
        // IsolatedStorageFile object.

        IsolatedStorageFile^ isoStore = IsolatedStorageFile::GetStore(IsolatedStorageScope::User |
            IsolatedStorageScope::Assembly, (Type ^)nullptr, (Type ^)nullptr);

        // This code creates a few files so that they can be enumerated.

        IsolatedStorageFileStream^ streamA =
            gcnew IsolatedStorageFileStream("TestFileA.Txt", FileMode::Create, isoStore);
        IsolatedStorageFileStream^ streamB =
            gcnew IsolatedStorageFileStream("TestFileB.Txt", FileMode::Create, isoStore);
        IsolatedStorageFileStream^ streamC =
            gcnew IsolatedStorageFileStream("TestFileC.Txt", FileMode::Create, isoStore);
        IsolatedStorageFileStream^ streamD =
            gcnew IsolatedStorageFileStream("TestFileD.Txt", FileMode::Create, isoStore);

        streamA->Close();
        streamB->Close();
        streamC->Close();
        streamD->Close();

        // There might be a small delay between when the above code
        // executes and when the files are created in the store.
        // Closing and opening the store in this example ensures that
        // the common language runtime has finished creating the files.
        isoStore->Close();
        isoStore = IsolatedStorageFile::GetStore(IsolatedStorageScope::User |
            IsolatedStorageScope::Assembly, (Type ^)nullptr, (Type ^)nullptr);

        // This line of code calls a method at the bottom of the program
        // that puts all the files in isoStore into an IEnumerator.

        IEnumerator^ allFiles = EnumerateTheStore(isoStore);
        long totalsize = 0;

        // This code counts up the sizes of all the stores.

        while (allFiles->MoveNext())
        {
            IsolatedStorageFile^ store = (IsolatedStorageFile^)allFiles->Current;
            totalsize += (long)store->UsedSize;
        }

        Console::WriteLine("The total size = " + totalsize);
        return 0;
    }

    // This method returns an enumerator of all the files for a user.

private:
    static IEnumerator^ EnumerateTheStore(IsolatedStorageFile^ isoStore)
    {
        IEnumerator^ e = IsolatedStorageFile::GetEnumerator(IsolatedStorageScope::User);

        return e;
    }
};

int main()
{
    EnumeratingStores::Main();
}


Show: