public void MultiLevel() { // see bug #4101 IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly(); try { isf.CreateDirectory("dir1"); string [] dirs = isf.GetDirectoryNames("*"); Assert.AreEqual(dirs.Length, 1, "1a"); Assert.AreEqual(dirs [0], "dir1", "1b"); isf.CreateDirectory("dir1/test"); dirs = isf.GetDirectoryNames("dir1/*"); Assert.AreEqual(dirs.Length, 1, "2a"); Assert.AreEqual(dirs [0], "test", "2b"); isf.CreateDirectory("dir1/test/test2a"); isf.CreateDirectory("dir1/test/test2b"); dirs = isf.GetDirectoryNames("dir1/test/*"); Assert.AreEqual(dirs.Length, 2, "3a"); Assert.AreEqual(dirs [0], "test2a", "3b"); Assert.AreEqual(dirs [1], "test2b", "3c"); } finally { isf.DeleteDirectory("dir1/test/test2a"); isf.DeleteDirectory("dir1/test/test2b"); isf.DeleteDirectory("dir1/test"); isf.DeleteDirectory("dir1"); } }
// Add dir/file recursively void AddFileToDirectory(IsoDirectory dir, IsolatedStorageFile isf) { string[] childrendir, childrenfile; if (string.IsNullOrEmpty(dir.FilePath)) { childrendir = isf.GetDirectoryNames(); childrenfile = isf.GetFileNames(); } else { childrendir = isf.GetDirectoryNames(dir.FilePath + "/"); childrenfile = isf.GetFileNames(dir.FilePath + "/"); } // Add directory entity foreach (var dirname in childrendir) { var childdir = new IsoDirectory(dirname, dir.FilePath + "/" + dirname); AddFileToDirectory(childdir, isf); dir.Children.Add(childdir); } // Add file entity foreach (var filename in childrenfile) { dir.Children.Add(new IsoFile(filename, dir.FilePath + "/" + filename)); } }
private static int countDirsNumber(IsolatedStorageFile isf, string strPath) { int length = isf.GetDirectoryNames(strPath + "/*").Length; foreach (string str in isf.GetDirectoryNames(strPath + "/*")) { length += countDirsNumber(isf, strPath + "/" + str); } return(length); }
[Test] // https://bugzilla.novell.com/show_bug.cgi?id=376188 public void CreateSubDirectory () { IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly (); isf.CreateDirectory ("subdir"); isf.CreateDirectory ("subdir/subdir2"); Assert.AreEqual (1, isf.GetDirectoryNames ("*").Length, "subdir"); Assert.AreEqual (1, isf.GetDirectoryNames ("subdir/*").Length, "subdir/subdir2"); isf.DeleteDirectory ("subdir/subdir2"); isf.DeleteDirectory ("subdir"); }
public string[] GetDirectorys(string p_SearchPattern) { if (string.IsNullOrEmpty(p_SearchPattern)) { return(StorageFileManage.GetDirectoryNames()); } else { return(StorageFileManage.GetDirectoryNames(p_SearchPattern)); } }
public void PurgeOldSessions() { string[] otherSessionKeys = _storage.GetDirectoryNames("ECollegeCache\\*"); foreach (string otherSessionKey in otherSessionKeys) { if (!_sessionKey.Equals(otherSessionKey)) { RecursiveDeleteDirectory(string.Format("ECollegeCache\\{0}", otherSessionKey)); } } }
/// <summary> /// Removes all items from this Isolated Storage area. /// </summary> public override void Flush() { lock (store) { string[] directories = store.GetDirectoryNames(GenerateSearchString(storageAreaName)); foreach (string itemLocation in directories) { string itemRoot = GenerateItemLocation(itemLocation); RemoveItem(itemRoot); } } }
public void ReadDirectoryAsFile() { string dirname = "this-is-a-dir"; IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForDomain(); try { string[] dirs = isf.GetDirectoryNames(dirname); if (dirs.Length == 0) { isf.CreateDirectory(dirname); } Read(dirname); } catch (UnauthorizedAccessException uae) { // check that we do not leak the full path to the missing file // as we do not have the FileIOPermission's PathDiscovery rights Assert.IsTrue(uae.Message.IndexOf(dirname) >= 0, "dirname"); Assert.IsFalse(uae.Message.IndexOf("\\" + dirname) >= 0, "fullpath"); try { isf.DeleteDirectory(dirname); } catch (IsolatedStorageException) { // this isn't where we want ot fail! // and 1.x isn't always cooperative } throw; } }
public static String[] GetAllDirectories(String pattern, IsolatedStorageFile store) { // obtain all the subfolders under the specified folder string root = System.IO.Path.GetDirectoryName(pattern); if (root != "") { root += "/"; } //get all folders string[] directories; directories = store.GetDirectoryNames(pattern); List <string> directoryList = new List <string>(directories); //get matched folders for (int i = 0, max = directories.Length; i < max; i++) { string directory = directoryList[i] + "/"; string[] more = GetAllDirectories(root + directory + "*", store); //iterate through each folder and add current path for (int j = 0; j < more.Length; j++) { more[j] = directory + more[j]; } // add the found folders into the array foreach (string sub in more) { directoryList.Insert(i + 1, sub); } i += more.Length; max += more.Length; } return((string[])directoryList.ToArray()); }
/// <summary> /// Copies a source directory to specified destination directory. /// </summary> /// <param name="src">Path of the source directory</param> /// <param name="dest">Path of the destination directory</param> internal static void CopyDirectory(string src, string dest) { using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication()) { if (!storage.DirectoryExists(dest)) { storage.CreateDirectory(dest); } // Copy all files. string[] files = storage.GetFileNames(src + "\\*.*"); foreach (string file in files) { string srcfile = Path.Combine(src, file); string destfile = Path.Combine(dest, file); // Delete file if exists if (storage.FileExists(destfile)) { storage.DeleteFile(destfile); } storage.CopyFile(srcfile, destfile); } // Process subdirectories. string[] dirs = storage.GetDirectoryNames(src + "\\*"); foreach (string dir in dirs) { string destinationDir = Path.Combine(dest, dir); string srcDir = Path.Combine(src, dir); CopyDirectory(srcDir, destinationDir); } } }
void IsoFileExplorer_Loaded(object sender, RoutedEventArgs e) { isoFile = IsolatedStorageFile.GetUserStoreForApplication(); string[] directories = isoFile.GetDirectoryNames(); string[] files = isoFile.GetFileNames(); ListBoxItem itm; FileList.Items.Clear(); foreach (string file in files) { if (file != "RecentPuzzles.xml") { itm = new ListBoxItem(); itm.Tag = FileLocation.IsolatedStorage; itm.Content = file; FileList.Items.Add(itm); } } string[] embeddedResources = this.GetType().Assembly.GetManifestResourceNames(); foreach (string item in embeddedResources) { string puzzlePrefix = "SilverSudoku.Puzzles"; if (item.Contains(puzzlePrefix)) { itm = new ListBoxItem(); itm.Tag = FileLocation.Assembly; itm.Content = item; FileList.Items.Add(itm); } } }
private void CopyDirectory(string sourceDir, string destDir, IsolatedStorageFile isoFile) { string path = File.AddSlashToDirectory(sourceDir); if (!isoFile.DirectoryExists(destDir)) { isoFile.CreateDirectory(destDir); } destDir = File.AddSlashToDirectory(destDir); string[] files = isoFile.GetFileNames(path + "*"); if (files.Length > 0) { foreach (string file in files) { isoFile.CopyFile(path + file, destDir + file); } } string[] dirs = isoFile.GetDirectoryNames(path + "*"); if (dirs.Length > 0) { foreach (string dir in dirs) { CopyDirectory(path + dir, destDir + dir, isoFile); } } }
public static bool emptyDir(string strPath) { if (!string.IsNullOrEmpty(strPath)) { try { using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication()) { if (!file.DirectoryExists(strPath)) { return(false); } foreach (string str in file.GetFileNames(strPath + "/*")) { file.DeleteFile(strPath + "/" + str); Log.d("StorageIO", "delete file " + strPath + "/" + str); } foreach (string str2 in file.GetDirectoryNames(strPath + "/*")) { deleteDir(file, strPath + "/" + str2, true); Log.d("StorageIO", "delete dir " + strPath + "/" + str2); } } return(true); } catch (Exception exception) { Log.e("StorageIO", string.Concat(new object[] { "emptyDir clear path fail=", strPath, " \n", exception })); } } return(false); }
public static List <string> dirsDetail(string strPath) { if (!string.IsNullOrEmpty(strPath)) { try { using (IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication()) { if (!file.DirectoryExists(strPath)) { return(null); } List <string> list = new List <string>(); foreach (string str in file.GetDirectoryNames(strPath + "/*")) { list.Add(strPath + "/" + str); } return(list); } } catch (Exception exception) { Log.e("StorageIO", string.Concat(new object[] { "dirsDetail Exception=", strPath, " \n", exception })); } } return(null); }
public static void DeleteAllAttachmentData() { string[] attachmentPaths = new string[2]; attachmentPaths[0] = HikeConstants.FILES_ATTACHMENT; attachmentPaths[1] = HikeConstants.FILES_BYTE_LOCATION; using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication()) { foreach (string attachmentPath in attachmentPaths) { if (store.DirectoryExists(attachmentPath)) { string[] directoryNames = store.GetDirectoryNames(attachmentPath + "/*"); foreach (string directoryName in directoryNames) { string escapedDirectoryName = directoryName.Replace(":", "_"); string[] fileNames = store.GetFileNames(attachmentPath + "/" + escapedDirectoryName + "/*"); foreach (string fileName in fileNames) { store.DeleteFile(attachmentPath + "/" + escapedDirectoryName + "/" + fileName); } } } } } }
//</snippet2> //<snippet6> public void DeleteFiles() { //<snippet9> try { IsolatedStorageFile isoFile = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain, typeof(System.Security.Policy.Url), typeof(System.Security.Policy.Url)); String[] dirNames = isoFile.GetDirectoryNames("*"); String[] fileNames = isoFile.GetFileNames("*"); //</snippet9> // List the files currently in this Isolated Storage. // The list represents all users who have personal // preferences stored for this application. if (fileNames.Length > 0) { for (int i = 0; i < fileNames.Length; ++i) { // Delete the files. isoFile.DeleteFile(fileNames[i]); } // Confirm that no files remain. fileNames = isoFile.GetFileNames("*"); } } catch (Exception e) { Console.WriteLine(e.ToString()); } }
//</snippet4> //<snippet3> public bool GetIsoStoreInfo() { // Get a User store with type evidence for the current Domain and the Assembly. IsolatedStorageFile isoFile = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain, typeof(System.Security.Policy.Url), typeof(System.Security.Policy.Url)); String[] dirNames = isoFile.GetDirectoryNames("*"); String[] fileNames = isoFile.GetFileNames("*"); // List directories currently in this Isolated Storage. if (dirNames.Length > 0) { for (int i = 0; i < dirNames.Length; ++i) { Console.WriteLine("Directory Name: " + dirNames[i]); } } // List the files currently in this Isolated Storage. // The list represents all users who have personal preferences stored for this application. if (fileNames.Length > 0) { for (int i = 0; i < fileNames.Length; ++i) { Console.WriteLine("File Name: " + fileNames[i]); } } isoFile.Close(); return(true); }
//******************************************************************************************* //Enable this if you'd like to be able access the list from outside the class. All list //methods are commented out below and replaced with Debug.WriteLine. //Default implementation is to simply output the directories to the console (Debug.WriteLine) //so if it looks like nothing's happening, check the Output window :) - keyboardP // public static List<string> listDir = new List<string>(); //******************************************************************************************** //Use "*" as the pattern string in order to retrieve all files and directories public static void GetIsolatedStorageView(string pattern, IsolatedStorageFile storeFile) { string root = System.IO.Path.GetDirectoryName(pattern); if (root != "") { root += "/"; } string[] directories = storeFile.GetDirectoryNames(pattern); //if the root directory has not FOLDERS, then the GetFiles() method won't be called. //the line below calls the GetFiles() method in this event so files are displayed //even if there are no folders //if (directories.Length == 0) GetFiles(root, "*", storeFile); for (int i = 0; i < directories.Length; i++) { string dir = directories[i] + "/"; //Add this directory into the list // listDir.Add(root + directories[i]); //Write to output window Debug.WriteLine(root + directories[i]); //Get all the files from this directory GetFiles(root + directories[i], pattern, storeFile); //Continue to get the next directory GetIsolatedStorageView(root + dir + "*", storeFile); } }
public static void DeleteDirectory(string folderToRemove) { try { //get all folders inside it Folder/* string[] folders = store.GetDirectoryNames(folderToRemove + "*"); for (int i = 0; i < folders.Length; i++) { DeleteDirectory(folderToRemove + folders[i] + "/"); } //get all files inside it string[] files = store.GetFileNames(folderToRemove + "*"); for (int i = 0; i < files.Length; i++) { store.DeleteFile(folderToRemove + files[i]); } //finally, delete this directory once it's empty store.DeleteDirectory(folderToRemove.TrimEnd('/')); } catch { Debug.WriteLine("Failed to delete directory"); } }
//deleting the directory public static void DeleteDirectoryRecursively(this IsolatedStorageFile storageFile, String dirName) { if (!storageFile.DirectoryExists(dirName)) { return; } String pattern = dirName + "/*"; String[] files = storageFile.GetFileNames(pattern); foreach (String fName in files) { String temp = dirName + "/" + fName + "\n"; if (storageFile.FileExists(temp)) { storageFile.DeleteFile(temp); } } String[] dirs = storageFile.GetDirectoryNames(pattern); foreach (String dName in dirs) { String temp = dirName + "/" + dName; if (storageFile.DirectoryExists(temp)) { DeleteDirectoryRecursively(storageFile, temp); } } storageFile.DeleteDirectory(dirName); }
public static void ClearDirectory(string dirName) { IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication(); if (!isoFile.DirectoryExists(dirName)) { return; } string[] dirNames = isoFile.GetDirectoryNames(dirName + "\\*"); string[] fileNames = isoFile.GetFileNames(dirName + "\\*"); if (fileNames.Length > 0) { for (int i = 0; i < fileNames.Length; i++) { isoFile.DeleteFile(System.IO.Path.Combine(dirName, fileNames[i])); } } if (dirNames.Length > 0) { for (int i = 0; i < dirNames.Length; i++) { ClearDirectory(System.IO.Path.Combine(dirName, dirNames[i])); isoFile.DeleteDirectory(System.IO.Path.Combine(dirName, dirNames[i])); } } }
private string EnsureDirectory() { if (this.Directory.IsEmpty()) { return(string.Empty); } ModuleProc PROC = new ModuleProc("HomeScreenWidgets", "EnsureDirectory"); string result = string.Empty; try { string[] dirNames = _storage.GetDirectoryNames(this.Directory); if (dirNames == null || dirNames.Length == 0) { _storage.CreateDirectory(this.Directory); } result = this.Directory; } catch (Exception ex) { Log.Exception(PROC, ex); } return(result); }
} // End of Main. // Method to retrieve all directories, recursively, within a store. public static List <String> GetAllDirectories(string pattern, IsolatedStorageFile storeFile) { // Get the root of the search string. string root = Path.GetDirectoryName(pattern); if (root != "") { root += "/"; } // Retrieve directories. List <String> directoryList = new List <String>(storeFile.GetDirectoryNames(pattern)); // Retrieve subdirectories of matches. for (int i = 0, max = directoryList.Count; i < max; i++) { string directory = directoryList[i] + "/"; List <String> more = GetAllDirectories(root + directory + "*", storeFile); // For each subdirectory found, add in the base path. for (int j = 0; j < more.Count; j++) { more[j] = directory + more[j]; } // Insert the subdirectories into the list and // update the counter and upper bound. directoryList.InsertRange(i + 1, more); i += more.Count; max += more.Count; } return(directoryList); }
private void LoadFileList(string path) { using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication()) { var fileItems = new List <FileItem>(); string searchPattern = Path.Combine(path, "*"); foreach (string directoryName in store.GetDirectoryNames(searchPattern)) { fileItems.Add(new FileItem() { Name = directoryName, Type = "directory" }); } foreach (string fileName in store.GetFileNames(searchPattern)) { fileItems.Add(new FileItem() { Name = fileName, Type = "file" }); } this.fileList.ItemsSource = fileItems; } }
// helper function from: http://stackoverflow.com/questions/18422331/easy-way-to-recursively-delete-directories-in-isolatedstorage-on-wp7-8 private void DeleteDirectoryRecursively(IsolatedStorageFile storageFile, String dirName) { try { String pattern = dirName + @"\*"; String[] files = storageFile.GetFileNames(pattern); foreach (var fName in files) { storageFile.DeleteFile(Path.Combine(dirName, fName)); } String[] dirs = storageFile.GetDirectoryNames(pattern); foreach (var dName in dirs) { DeleteDirectoryRecursively(storageFile, Path.Combine(dirName, dName)); } if (storageFile.DirectoryExists(dirName)) { storageFile.DeleteDirectory(dirName); } } catch (Exception e) { Debug.WriteLine("Unable to delete directory : " + dirName); } }
public static void ClearCache() { String tempUsername = AppUser.Instance.UserName; String tempPassword = AppUser.Instance.Password; IsolatedStorageFile myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication(); foreach (String file in myIsolatedStorage.GetFileNames()) { try { if (file.Equals("wptrakt.sdf")) { if (MovieDao.Instance.DatabaseExists()) { try { MovieDao.Instance.DeleteDatabase(); MovieDao.Instance.Dispose(); MovieDao.DisposeDB(); } catch (IOException) { } } if (ShowDao.Instance.DatabaseExists()) { try { ShowDao.Instance.DeleteDatabase(); ShowDao.Instance.Dispose(); ShowDao.DisposeDB(); } catch (IOException) { } } } myIsolatedStorage.DeleteFile(file); } catch (IsolatedStorageException) { }; } IsolatedStorageSettings.ApplicationSettings["UserName"] = tempUsername; IsolatedStorageSettings.ApplicationSettings["Password"] = tempPassword; IsolatedStorageSettings.ApplicationSettings.Save(); foreach (String dir in myIsolatedStorage.GetDirectoryNames()) { if (!dir.Contains("Shared")) { foreach (String file in myIsolatedStorage.GetFileNames(dir + "/*")) { try { myIsolatedStorage.DeleteFile(dir + "/" + file); } catch (IsolatedStorageException) { }; } } } }
public void GetDirsInSubDirs() { IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly(); isf.CreateDirectory("subdir"); string [] dir_names = isf.GetDirectoryNames("subdir/../*"); }
//--------------------------------------------------------------------------------------------------------- //Wird bei jedem Aufruf der Seite ausgeführt //--------------------------------------------------------------------------------------------------------------------------------- protected override void OnNavigatedTo(NavigationEventArgs e) { //File erstellen IsolatedStorageFile file = IsolatedStorageFile.GetUserStoreForApplication(); //Variable für Ordner ermitteln string[] AllFolders = file.GetDirectoryNames("/Folders/"); int FolderID = Convert.ToInt32(NavigationContext.QueryString["folder"]); Folder = AllFolders[FolderID]; base.OnNavigatedTo(e); //ImageCount laden //Anzahl erstellter Bilder FileStream filestream = file.OpenFile("Settings/ImageCount.txt", FileMode.Open); StreamReader sr = new StreamReader(filestream); String tempSr = sr.ReadToEnd(); filestream.Close(); ImageCount = Convert.ToInt32(tempSr); //Image.dat laden filestream = file.OpenFile("Thumbs/" + Folder + ".dat", FileMode.Open); sr = new StreamReader(filestream); ImagesAll = sr.ReadToEnd(); filestream.Close(); ImagesAll = ImagesAll.TrimEnd(new char[] { '\r', '\n' }); //Bilder laden GetImages("first"); }
public static bool delDirIsoStorBeforeUnzip(string dirName) { bool result; try { IsolatedStorageFile userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication(); string text = dirName + "\\*"; string[] fileNames = userStoreForApplication.GetFileNames(text); string[] array = fileNames; for (int i = 0; i < array.Length; i++) { string text2 = array[i]; userStoreForApplication.DeleteFile(Path.Combine(dirName, text2)); } string[] directoryNames = userStoreForApplication.GetDirectoryNames(text); string[] array2 = directoryNames; for (int j = 0; j < array2.Length; j++) { string text3 = array2[j]; delDirIsoStorBeforeUnzip(Path.Combine(dirName, text3)); } userStoreForApplication.DeleteDirectory(dirName); result = true; } catch (Exception ex) { // WLUtils.LOG("cleaning or IsolatedStorage (directupdate skins) .... " + ex); result = false; } return(result); }
private IEnumerable <string> GetAllDirectoryNames(IsolatedStorageFile isf, string rootPath) { List <string> allDirs = new List <string>(); // Gets the paths of sub-directories of first level in rootPath. IEnumerable <string> subPaths; try { subPaths = isf .GetDirectoryNames(rootPath + "/*") .Select(s => rootPath + "/" + s); } catch (Exception) { subPaths = new string[] { }; } // For each of them, check for sub-directories. foreach (string subPath in subPaths) { allDirs.AddRange(GetAllDirectoryNames(isf, subPath)); } // Adds the root path to the list. allDirs.Add(rootPath); return(allDirs); }