private static void GetFiles(string dir, string pattern, IsolatedStorageFile storeFile) { string fileString = System.IO.Path.GetFileName(pattern); string[] files = storeFile.GetFileNames(pattern); try { for (int i = 0; i < storeFile.GetFileNames(dir + "/" + fileString).Length; i++) { //Files are prefixed with "--" //Add to the list //listDir.Add("--" + dir + "/" + storeFile.GetFileNames(dir + "/" + fileString)[i]); Debug.WriteLine("--" + dir + "/" + storeFile.GetFileNames(dir + "/" + fileString)[i]); } } catch (IsolatedStorageException ise) { Debug.WriteLine("An IsolatedStorageException exception has occurred: " + ise.InnerException); } catch (Exception e) { Debug.WriteLine("An exception has occurred: " + e.InnerException); } }
/// <summary> /// Collects the Paths of Directories and Files inside a given Directory relative to it. /// </summary> /// <param name="Iso">The Isolated Storage to Use</param> /// <param name="directory">The Directory to crawl</param> /// <param name="relativeSubDirectories">relative Paths to the subdirectories in the given directory, ordered top - down</param> /// <param name="relativeSubFiles">relative Paths to the files in the given directory and its children, ordered top - down</param> private static void CollectSubdirectoriesAndFilesBreadthFirst(IsolatedStorageFile Iso, string directory, out IList<string> relativeSubDirectories, out IList<string> relativeSubFiles) { var relativeDirs = new List<string>(); var relativeFiles = new List<string>(); var toDo = new Queue<string>(); toDo.Enqueue(string.Empty); while (toDo.Count > 0) { var relativeSubDir = toDo.Dequeue(); var absoluteSubDir = Path.Combine(directory, relativeSubDir); var queryString = string.Format("{0}\\*", absoluteSubDir); foreach (var file in Iso.GetFileNames(queryString)) { relativeFiles.Add(Path.Combine(relativeSubDir, file)); } foreach (var dir in Iso.GetDirectoryNames(queryString)) { var relativeSubSubdir = Path.Combine(relativeSubDir, dir); toDo.Enqueue(relativeSubSubdir); relativeDirs.Add(relativeSubSubdir); } } relativeSubDirectories = relativeDirs; relativeSubFiles = relativeFiles; }
public void GetFileNames_RaisesInvalidPath() { using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly()) { Assert.Throws <ArgumentException>(() => isf.GetFileNames("\0bad")); } }
//TODO : verify we don't need the method below using Bridge #if !BRIDGE // public acces´s for tests public static void LoadData() { // IsolatedStorageFile isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly, null, null); IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForAssembly(); if (isoStore.GetFileNames(Filename).Length == 0) { // File not exists. Let us NOT try to DeSerialize it. return; } // Read the stream from Isolated Storage. Stream stream = new IsolatedStorageFileStream(Filename, FileMode.OpenOrCreate, isoStore); try { // DeSerialize the Dictionary from stream. object bytes = Formatter.Deserialize(stream); var appData = (Dictionary <string, object>)bytes; // Enumerate through the collection and load our Dictionary. IDictionaryEnumerator enumerator = appData.GetEnumerator(); while (enumerator.MoveNext()) { AppDictionary[enumerator.Key.ToString()] = enumerator.Value; } } finally { stream.Close(); } }
public void GetFileNames_RaisesInvalidPath_Core() { // We are no longer as aggressive with filters for enumerating files using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly()) { isf.GetFileNames("\0bad"); } }
public static string[] GetFilesName(string path) { System.IO.IsolatedStorage.IsolatedStorageFile isf = System.IO.IsolatedStorage.IsolatedStorageFile.GetUserStoreForApplication(); string searchpath = System.IO.Path.Combine(path, "*.*"); string[] filesInSubDirs = isf.GetFileNames(searchpath); return(filesInSubDirs); }
public void GetFileNames_Closed_ThrowsInvalidOperationException() { using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly()) { isf.Close(); Assert.Throws <InvalidOperationException>(() => isf.GetFileNames("foo")); } }
public void GetFileNames_ThrowsIsolatedStorageException() { using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForAssembly()) { isf.Remove(); Assert.Throws <IsolatedStorageException>(() => isf.GetFileNames("foo")); } }
public static List<String> GetAllFiles(string pattern, IsolatedStorageFile storeFile) { // Get the root and file portions of the search string. string fileString = Path.GetFileName(pattern); List<String> fileList = new List<String>(storeFile.GetFileNames(pattern)); // Loop through the subdirectories, collect matches, // and make separators consistent. foreach (string directory in GetAllDirectories("*", storeFile)) { foreach (string file in storeFile.GetFileNames(directory + "/" + fileString)) { fileList.Add((directory + "/" + file)); } } return fileList; }
private void DeleteAllFilesInDirectory(IsolatedStorageFile store, string path) { if (!store.DirectoryExists(path)) { return; } var files = store.GetFileNames(path + "/*"); foreach (var file in files) { store.DeleteFile(path + "/" + file); } }
private void InnerClear(IsolatedStorageFile iso, string path) { var fs = iso.GetFileNames(string.Format("{0}/*", path)); foreach (var f in fs) { iso.DeleteFile(Path.Combine(path, f)); } var ds = iso.GetDirectoryNames(string.Format("{0}/*", path)); foreach (var d in ds) { var sp = Path.Combine(path, d); this.InnerClear(iso, sp); iso.DeleteDirectory(sp); } }
// use the caller stack to execute some read operations private void Read (IsolatedStorageFile isf) { Assert.IsNotNull (isf.GetDirectoryNames ("*"), "GetDirectoryNames"); Assert.IsNotNull (isf.GetFileNames ("*"), "GetFileNames"); try { Assert.IsTrue (isf.CurrentSize >= 0, "CurrentSize"); Assert.IsTrue (isf.MaximumSize >= isf.CurrentSize, "MaximumSize"); } catch (InvalidOperationException) { // roaming } }
public static void RecursiveDeleteDirectory(string directory, IsolatedStorageFile store) { foreach (var fileName in store.GetFileNames(directory + "\\*")) { store.DeleteFile(directory + "\\" + fileName); } foreach (var directoryName in store.GetDirectoryNames(directory + "\\*")) { RecursiveDeleteDirectory(directory + "\\" + directoryName, store); } store.DeleteDirectory(directory); }
public override void Clear() { base.Clear(); using ( _storage = IsolatedStorageFile.GetUserStoreForApplication() ) { try { foreach ( string file in _storage.GetFileNames( CACHE_FOLDER + @"\*" ) ) { _storage.DeleteFile( GetFilePath( file ) ); } } catch ( Exception e ) { e.ToString(); } } }
public IsolatedStorageCrawlerQueueService(Uri crawlStart, bool resume) { m_CrawlStart = crawlStart; m_Store = IsolatedStorageFile.GetMachineStoreForDomain(); if (!resume) { Clean(); } else { Initialize(); m_Count = m_Store.GetFileNames(Path.Combine(WorkFolderPath, "*")).Count(); } }
public static void DeleteDirectoryRecursively(IsolatedStorageFile storageFile, string directoryName) { var pattern = directoryName + @"\*"; var files = storageFile.GetFileNames(pattern); foreach (var fileName in files) { storageFile.DeleteFile(Path.Combine(directoryName, fileName)); } var dirs = storageFile.GetDirectoryNames(pattern); foreach (var dirName in dirs) { DeleteDirectoryRecursively(storageFile, Path.Combine(directoryName, dirName)); } storageFile.DeleteDirectory(directoryName); }
public void DeleteDirectoryRecursive(IsolatedStorageFile isolatedStorageFile, String dirName) { String pattern = dirName + @"\*"; String[] files = isolatedStorageFile.GetFileNames(pattern); foreach (String fName in files) { isolatedStorageFile.DeleteFile(Path.Combine(dirName, fName)); } String[] dirs = isolatedStorageFile.GetDirectoryNames(pattern); foreach (String dName in dirs) { DeleteDirectoryRecursive(isolatedStorageFile, Path.Combine(dirName, dName)); } isolatedStorageFile.DeleteDirectory(dirName); }
public static void TryToDeleteAllFiles(IsolatedStorageFile storageFolder, string directory) { if (storageFolder.DirectoryExists(directory)) { try { string[] files = storageFolder.GetFileNames(directory); foreach (string File in files) { storageFolder.DeleteFile(directory + files); } } catch (Exception) { //ignoring the exception } } }
/// <summary> /// delete files in directory /// </summary> /// <param name="storageFolder"></param> /// <param name="directory"></param> private static void TryToDeleteAllFiles(IsolatedStorageFile storageFolder, string directory) { if (storageFolder.DirectoryExists(directory)) { try { string[] files = storageFolder.GetFileNames(directory); foreach (string file in files) { storageFolder.DeleteFile(directory + file); } } catch (Exception) { // could be in use } } }
private static void CleanupLogs(IsolatedStorageFile store, string logFolder) { var files = store.GetFileNames(logFolder); var fileCount = files.Count(); if (fileCount > MAX_FILE_COUNT - 1) { var filesAgeAsc = from file in files let age = store.GetCreationTime(file) orderby age ascending select file; var deleteFiles = filesAgeAsc.Take(fileCount - MAX_FILE_COUNT + 1); foreach (var file in deleteFiles) { var filePath = Path.Combine(logFolder, file); store.DeleteFile(filePath); } } }
public static void DeleteDirectory(IsolatedStorageFile store, String root) { String dir = root; // delete file in current dir foreach (String file in store.GetFileNames(dir + "/*")) { store.DeleteFile(dir + "/" + file); } // delete sub-dir foreach (String subdir in store.GetDirectoryNames(dir + "/*")) { DeleteDirectory(store, dir + "/" + subdir + "/"); } // delete current dir store.DeleteDirectory(dir); }
public string Read(string filename) { string result = string.Empty; System.IO.IsolatedStorage.IsolatedStorageFile isoStore = System.IO.IsolatedStorage.IsolatedStorageFile. GetUserStoreForDomain(); try { // Checks to see if the options.txt file exists. if (isoStore.GetFileNames(filename).GetLength(0) != 0) { // Opens the file because it exists. System.IO.IsolatedStorage.IsolatedStorageFileStream isos = new System.IO.IsolatedStorage.IsolatedStorageFileStream (filename, System.IO.FileMode.Open, isoStore); System.IO.StreamReader reader = null; try { reader = new System.IO.StreamReader(isos); // Reads the values stored. result = reader.ReadLine(); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine ("Cannot read options " + ex.ToString()); } finally { reader.Close(); } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine ("Cannot read options " + ex.ToString()); } return(result); }
/// <summary> /// Loads local audio information. /// </summary> public void ReadAudioFileInfo() { AudioFiles.Clear(); // Load the image which was filtered from isolated app storage. System.IO.IsolatedStorage.IsolatedStorageFile myStore = IsolatedStorageFile.GetUserStoreForApplication(); try { string[] fileNames = myStore.GetFileNames(); foreach (string s in fileNames) { AudioFileModel audioFile = new AudioFileModel(); audioFile.FileName = s; IsolatedStorageFileStream fileStream = myStore.OpenFile(s, System.IO.FileMode.Open, System.IO.FileAccess.Read); audioFile.FileSize = "" + fileStream.Length + " bytes"; // Read sample rate and channel count Encoding encoding = Encoding.UTF8; byte[] bytes = new byte[4]; // channel count fileStream.Seek(22, SeekOrigin.Begin); fileStream.Read(bytes, 0, 2); audioFile.ChannelCount = BitConverter.ToInt16(bytes, 0); // sample rate fileStream.Read(bytes, 0, 4); audioFile.SampleRate = BitConverter.ToInt32(bytes, 0); audioFile.FileLength = "" + fileStream.Length / (2 * audioFile.SampleRate * audioFile.ChannelCount) + " seconds"; AudioFiles.Add(audioFile); fileStream.Dispose(); } } catch { MessageBox.Show("Error while trying to read audio files."); } }
// Writes the button options to the isolated storage. public void Write(string filename, string content) { System.IO.IsolatedStorage.IsolatedStorageFile isoStore = System.IO.IsolatedStorage.IsolatedStorageFile. GetUserStoreForDomain(); try { // Checks if the file exists and, if it does, tries to delete it. if (isoStore.GetFileNames(filename).GetLength(0) != 0) { isoStore.DeleteFile(filename); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine ("Cannot delete file " + ex.ToString()); } // Creates the options file and writes the button options to it. System.IO.StreamWriter writer = null; try { System.IO.IsolatedStorage.IsolatedStorageFileStream isos = new System.IO.IsolatedStorage.IsolatedStorageFileStream(filename, System.IO.FileMode.CreateNew, isoStore); writer = new System.IO.StreamWriter(isos); writer.WriteLine(content); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine ("Cannot write options " + ex.ToString()); } finally { writer.Close(); } }
/// <summary> /// Returns the first-in-queue report file. If there are no files queued, returns <see langword="null"/>. /// </summary> /// <returns>Report file stream.</returns> public Stream GetFirstReportFile(out string fileName) { _isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain, null, null); fileName = _isoStore.GetFileNames("Exception_*.zip").FirstOrDefault(); if (fileName == null) { return null; } try { return new IsolatedStorageFileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.None); } catch (IOException exception) { // If the file is locked (as per IOException), then probably another instance of the library is already accessing // the file so let the other instance handle the file Logger.Error("Cannot access the report file at isolated storage (it is probably locked, see the inner exception): [Isolated Storage Directory]\\" + fileName, exception); return null; } }
public void CopyDirectory(string sourcePath, string destinationPath, IsolatedStorageFile iso) { if (!iso.DirectoryExists(sourcePath)) return; var folders = iso.GetDirectoryNames(sourcePath + "/" + "*.*"); foreach (var folder in folders) { string sourceFolderPath = sourcePath + "/" + folder; string destinationFolderPath = destinationPath + "/" + folder; iso.CreateDirectory(destinationFolderPath); CopyDirectory(sourceFolderPath, destinationFolderPath, iso); } foreach (var file in iso.GetFileNames(sourcePath + "/" + "*.*")) { string sourceFilePath = sourcePath + "/" + file; string destinationFilePath = destinationPath + "/" + file; iso.CopyFile(sourceFilePath, destinationFilePath); } }
private void ImportSavegamesCache(IsolatedStorageFile isf) { string[] gwsFiles = isf.GetFileNames(GetCachePathCore("*.gws")); if (gwsFiles == null) { return; } // For each file, imports its metadata. List<CartridgeSavegame> cSavegames = new List<CartridgeSavegame>(); foreach (string file in gwsFiles) { try { cSavegames.Add(CartridgeSavegame.FromCache(GetCachePathCore(file), isf)); } catch (Exception ex) { // Outputs the exception. System.Diagnostics.Debug.WriteLine("CartridgeTag: WARNING: Exception during savegame import."); DebugUtils.DumpException(ex); } } // Sets the savegame list. _savegames = cSavegames; RaisePropertyChanged("Savegames"); }
private void DeleteDirectory(string path, IsolatedStorageFile iso) { if (!iso.DirectoryExists(path)) return; var folders = iso.GetDirectoryNames(path + "/" + "*.*"); foreach (var folder in folders) { string folderPath = path + "/" + folder; DeleteDirectory(folderPath, iso); } foreach (var file in iso.GetFileNames(path + "/" + "*.*")) { iso.DeleteFile(path + "/" + file); } if (path != "") iso.DeleteDirectory(path); }
/// <summary> /// Deletes the saved state files from isolated storage. /// </summary> private void DeleteState(IsolatedStorageFile storage) { // get all of the files in the directory and delete them string[] files = storage.GetFileNames("ScreenManager\\*"); foreach (string file in files) { storage.DeleteFile(Path.Combine("ScreenManager", file)); } }
private void ScanDir(IsolatedStorageFile store, string directory, bool recurse) { try { string fileSearchPath = Path.Combine(directory, "*.*"); string[] names = store.GetFileNames(fileSearchPath); bool hasMatch = false; for (int fileIndex = 0; fileIndex < names.Length; ++fileIndex) { if (!fileFilter_.IsMatch(names[fileIndex])) { names[fileIndex] = null; } else { hasMatch = true; } } OnProcessDirectory(directory, hasMatch); if (alive_ && hasMatch) { foreach (string fileName in names) { var filePath = Path.Combine(directory, fileName); try { OnProcessFile(filePath); if (!alive_) { break; } } catch (Exception e) { if (!OnFileFailure(filePath, e)) { throw; } } } } } catch (Exception e) { if (!OnDirectoryFailure(directory, e)) { throw; } } if (alive_ && recurse) { try { string[] names = store.GetDirectoryNames(Path.Combine(directory, "*")); foreach (string subdir in names) { var fulldir = Path.Combine(directory, subdir); if ((directoryFilter_ == null) || (directoryFilter_.IsMatch(fulldir))) { ScanDir(store, fulldir, true); if (!alive_) { break; } } } } catch (Exception e) { if (!OnDirectoryFailure(directory, e)) { throw; } } } }
/// <summary> /// Evict an entry if we need to make room for a new one. /// </summary> /// <remarks> /// "A cache without an eviction policy is a memory leak" /// We might run into quota limits on IsolatedStorage. We need to check those, and evict files to make room. /// /// Cache eviction policy is "least recently updated" /// Note this is not the same as least recently used. /// Rather, we're evicting the entry that will expire soonest. /// /// This function assumes the caller has already locked fileAccessSync /// </remarks> /// <param name="iso"></param> private void EvictIfNecessary(IsolatedStorageFile iso) { if (metadata.GetNumberEntries() >= this.Capacity) { string[] filesInCache = iso.GetFileNames(this.Name + "\\*"); // This should never happen, but if the file count doesn't match // go and clean up the cache if (filesInCache.Length > metadata.GetNumberEntries()) { Debug.Assert(false); foreach (string filename in filesInCache) { // the GetFileNames call above does not return qualified paths, but we expect those for the rest of the calls string qualifiedFilename = Path.Combine(this.Name, filename); DateTime? updateTime = metadata.GetUpdateTime(qualifiedFilename); if (null == updateTime) { // Then we have a file in the cache, but no record of it being put there... clean it up // Most common way to hit this would be that I changed the internal naming format between versions. iso.DeleteFile(qualifiedFilename); } } } KeyValuePair<string, DateTime> oldestFile = metadata.GetOldestFile(); // If we are over capacity, there should always be at least one over-capacity file Debug.Assert(string.IsNullOrEmpty(oldestFile.Key) == false); if (string.IsNullOrEmpty(oldestFile.Key) == false) { iso.DeleteFile(oldestFile.Key); metadata.RemoveUpdateTime(oldestFile.Key); CacheEvictions++; } } }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Window_Loaded(object sender, RoutedEventArgs e) { myLibraryItemNames = new List<Xassida>(); BookPage titlePage, tardioumanePage, bp; LoadXassida(); this.DataContext = currentXassida; PagesCollection = new PaginatedCollection<Beyit>(currentXassida.Beyits); /// the title of the xassida will be the first page /// titlePage = new BookPage(); StackPanel p = new StackPanel() { VerticalAlignment = VerticalAlignment.Center }; TextBlock tPageTb = new TextBlock() { Text = currentXassida.Titre, FontSize = 35, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, TextAlignment = TextAlignment.Center, TextWrapping = TextWrapping.Wrap }; p.Children.Add(tPageTb); titlePage.Content = p; readerBook.Items.Add(titlePage); tardioumanePage = new BookPage(); tardioumanePage.Content = new TextBlock() { Text = currentXassida.Tardioumane, TextWrapping = TextWrapping.WrapWithOverflow, VerticalAlignment = VerticalAlignment.Center, }; readerBook.Items.Add(tardioumanePage); for (int i = 0; i < PagesCollection.PagesCount; i++) { bp = new BookPage(); StackPanel container = new StackPanel() { Orientation = Orientation.Vertical, VerticalAlignment = VerticalAlignment.Center }; foreach (Beyit beyit in PagesCollection.GetData(i)) { DockPanel c = new DockPanel(); foreach (Bahru bahru in beyit.Bahrus) { TextBlock tb = new TextBlock() { Text = bahru.Contenu, Margin = new Thickness(4, 6, 4, 6), Width = 50 }; c.Children.Add(tb); } container.Children.Add(c); } container.Children.Add(new TextBlock() { Text = String.Format("page {0}", (i + 1).ToString()), Foreground = SystemColors.GrayTextBrush, FontSize = 7, Margin = new Thickness(0, 10, 0, 10) }); bp.Content = container; readerBook.Items.Add(bp); } AppStore = IsolatedStorageFile.GetUserStoreForDomain(); // Check for files saved in isolated storage foreach (string file in AppStore.GetFileNames()) { myLibraryItemNames.Add(new Xassida() { Titre = file}); } // Set the items source of the myLibrary List view myLibraryListView.ItemsSource = myLibraryItemNames; }
private static void Upgrade(IsolatedStorageFile store) { var files = new List<string>( store.GetFileNames()); if (!files.Contains("Database.kdbx")) return; var appSettings = IsolatedStorageSettings .ApplicationSettings; string url; if (!appSettings.TryGetValue("Url", out url)) url = null; var info = new DatabaseInfo(); using (var fs = store.OpenFile("Database.kdbx", FileMode.Open)) { var source = string.IsNullOrEmpty(url) ? "WinPass" : DatabaseUpdater.WEB_UPDATER; var details = new DatabaseDetails { Url = url, Source = source, Type = SourceTypes.OneTime, Name = "WinPass 1.x database", }; info.SetDatabase(fs, details); } store.DeleteFile("Database.kdbx"); store.DeleteFile("Protection.bin"); store.DeleteFile("Decrypted.xml"); }
// Determinates whether the given file exists in the given storage private static bool FileExists(IsolatedStorageFile storage, string fileName) { var files = storage.GetFileNames(fileName); return files.Length != 0; }
private static IEnumerable<string> GetDebugFiles(IsolatedStorageFile isf, bool includeRawData) { return isf.GetFileNames("/Debug/") .Where(s => includeRawData || !s.Contains("rawdata")); }
// Can't delete unless empty. Must recursively delete files and folders private static void DeleteDirectory(IsolatedStorageFile storage, string dir) { foreach (var file in storage.GetFileNames(Path.Combine(dir, "*"))) { storage.DeleteFile(Path.Combine(dir, file)); } foreach (var subDir in storage.GetDirectoryNames(Path.Combine(dir, "*"))) { DeleteDirectory(storage, Path.Combine(dir, subDir)); } storage.DeleteDirectory(dir); }
private void CopyDirectory(string sourceDir, string destDir, IsolatedStorageFile isoFile) { string path = File.AddSlashToDirectory(sourceDir); bool bExists = isoFile.DirectoryExists(destDir); if (!bExists) { 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, true); } } string[] dirs = isoFile.GetDirectoryNames(path + "*"); if (dirs.Length > 0) { foreach (string dir in dirs) { CopyDirectory(path + dir, destDir + dir, isoFile); } } }
/// <summary> /// Deletes the saved state files from isolated storage. /// </summary> private void DeleteState(IsolatedStorageFile storage) { // glob on all of the files in the directory and delete them string[] files = storage.GetFileNames(System.IO.Path.Combine(m_sStorageDirName, "*")); foreach (string file in files) { storage.DeleteFile(Path.Combine(m_sStorageDirName, file)); } }
// 用递归方法增加目录/文件 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 + "/"); } // 增加目录实体 foreach (var dirname in childrendir) { var childdir = new IsoDirectory(dirname, dir.FilePath + "/" + dirname); AddFileToDirectory(childdir, isf); dir.Children.Add(childdir); } // 增加文件实体 foreach (var filename in childrenfile) { dir.Children.Add(new IsoFile(filename, dir.FilePath + "/" + filename)); } }