C# StorageFolder.GetFilesAsync方法代码示例

        private async void GetAllFiles(StorageFolder folder, ObservableCollection<Song> songs)
        {
            foreach (StorageFile file in await folder.GetFilesAsync())
            {
                if(file.FileType == ".mp3")
                {
                    var props = await file.Properties.GetMusicPropertiesAsync();
                    var image = await file.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.MusicView);
                    var cover = new BitmapImage();
                    cover.SetSource(image);
                    Song song = new Song()
                    {
                        Name = props.Title,
                        Album = props.Album,
                        Artist = props.Artist,
                        Cover = cover,
                        File = file
                    };
                    songs.Add(song);
                }
            }

            foreach (StorageFolder subfolder in await folder.GetFoldersAsync())
            {
                GetAllFiles(subfolder, songs);
            }
        }

        /// <summary>
        /// Gets a new filename which starts as the base filename parameter, but has a different end part.
        /// </summary>
        /// <param name="folder">The folder where the name will be checked.</param>
        /// <param name="baseFileName">Base filename to use as root.</param>
        /// <returns>
        /// The new filename.
        /// </returns>
        /// <example>
        /// In case that "naruto" does not exist in folder.
        /// GetNewFileName(folder, "naruto") -&gt; "naruto"
        /// GetNewFileName(folder, "naruto") -&gt; "naruto_1"
        /// GetNewFileName(folder, "naruto") -&gt; "naruto_2"
        /// ...
        ///   </example>
        public static string GetNewFileName(StorageFolder folder, string baseFileName)
        {
            try
            {
                var names = folder.GetFilesAsync()
                                .AsTask().Result
                                .Select(f => Path.GetFileNameWithoutExtension(f.Name));

                string possibleName = baseFileName;
                int index = 1;
                while (true)
                {
                    if (names.Any(n => n.Equals(possibleName, StringComparison.CurrentCultureIgnoreCase)))
                    {
                        possibleName = baseFileName + index++;
                    }
                    else
                    {
                        break;
                    }
                }

                return possibleName;
            }
            catch (Exception)
            {
                return baseFileName;
            }
        }

 private async void GetMusics(StorageFolder folder)
 {
     // Get all the songs in the folder past in parameter
     foreach (var item in await folder.GetFilesAsync())
     {
         if (item.FileType == ".mp3")
             allSongs.Add(item);
     }
 }

        public async Task<int> SelectGameExecutables(StorageFolder folder)
        {
            IEnumerable<StorageFile> retrievedFiles = await folder.GetFilesAsync(Windows.Storage.Search.CommonFileQuery.OrderByName);
            var fileCount = retrievedFiles.Count();

            Files = retrievedFiles.Where(file => ValidateFile(file)).ToList();

            return Files.Count;
        }

 public async Task getFiles(List<StorageFile> list, StorageFolder parent)
 {
     foreach (var item in await parent.GetFilesAsync())
     {
         list.Add(item);
     }
     foreach (var item in await parent.GetFoldersAsync())
         await getFiles(list, item);
 }

 public async Task getFiles(List<StorageFile> list, StorageFolder parent)
 {   //get all files of type folder search use Recursion
     foreach (var item in await parent.GetFilesAsync())
     {
         list.Add(item);
     }
     foreach (var item in await parent.GetFoldersAsync())
         await getFiles(list, item);
 }

        private async Task retrieveFilesInFolders(ObservableCollection<StorageFile> list,StorageFolder parent)
        {
            foreach (var item in await parent.GetFilesAsync())
            {
                if (item.FileType == ".mp3")
                    list.Add(item);
            }

            foreach (var item in await parent.GetFoldersAsync())
            {
                await retrieveFilesInFolders(list, item);
            }
        }

 internal async static Task MergeFolders(StorageFolder source, StorageFolder target)
 {
     foreach (StorageFile sourceFile in await source.GetFilesAsync())
     {
         await sourceFile.CopyAndReplaceAsync(await target.CreateFileAsync(sourceFile.Name, CreationCollisionOption.OpenIfExists));
     }
     
     foreach (StorageFolder sourceDirectory in await source.GetFoldersAsync())
     {
         StorageFolder nextTargetSubDir = await target.CreateFolderAsync(sourceDirectory.Name, CreationCollisionOption.OpenIfExists);
         await MergeFolders(sourceDirectory, nextTargetSubDir);
     }
 }

 /// <summary>
 /// Initializes this instance.
 /// Load the images of Mobile Vikings team.
 /// </summary>
 /// <returns></returns>
 public async Task<bool> Initialize()
 {
     try
     {
         var assets = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("Assets");
         _folder = await assets.GetFolderAsync("People");
         _files = await _folder.GetFilesAsync();
     }
     catch (Exception ex)
     {
         return false;
     }
     return true;
 }

 private async void LoadImagesFromDirectory(StorageFolder imagesdirectory)
 {
     Images.Clear();
     var files = await imagesdirectory.GetFilesAsync();
     foreach (var file in files)
     {
         Images.Add(new PhotoDto
         {
             ID = Guid.NewGuid(),
             Image = await LoadImage(file)
         });
             
     }
 }

        // first - a method to retrieve files from folder recursively 
        private static async Task RetriveFilesInFolder(List<StorageFile> list, StorageFolder parent)
        {
            list.AddRange((await parent.GetFilesAsync()).Where(p => 
                p.FileType == ".wma" 
                || p.FileType == ".flac"
                || p.FileType == ".m4a"
                || p.FileType == ".mp3"));

            //avoiding DRM folder of xbox music
            foreach (var folder in (await parent.GetFoldersAsync()).Where(folder =>
                folder.Name != "Xbox Music" && folder.Name != "Subscription Cache" && folder.Name != "Podcasts"))
            {
                await RetriveFilesInFolder(list, folder);
            }
        }

        async Task<List<string>> _getAllFilesInFolderRecurse(StorageFolder currentFolder, string topFolder)
        {
            List<string> files = new List<string>();

            foreach (var f in await currentFolder.GetFoldersAsync())
            {
                files.AddRange(await _getAllFilesInFolderRecurse(f, topFolder));
            }

            var filesResult = await currentFolder.GetFilesAsync();

            var filesString = filesResult.Select(_ => _.Path.Replace(topFolder, "").Trim('\\')).ToList();
            files.AddRange(filesString);
            return files;
        }

        /// <summary>
        /// Returns the number of files within the Oxford Whitelist
        /// </summary>
        public static async Task<int> GetFileCountInWhitelist(StorageFolder folder)
        {
            int fileCount = 0;

            fileCount += (await folder.GetFilesAsync()).Count;

            var subFolders = await folder.GetFoldersAsync();

            foreach(var subFolder in subFolders)
            {
                fileCount += (await subFolder.GetFilesAsync()).Count;
            }

            return fileCount;
        }

        public async void GetAllPictures(StorageFolder folder)
        {
            // Get all the Pictures in the folder past in parameter
            foreach (var item in await folder.GetFilesAsync())
            {
                if (item.FileType == ".jpg" || item.FileType == ".jpeg"
                    || item.FileType == ".tif" || item.FileType == ".tiff"
                    || item.FileType == ".png" || item.FileType == ".gif"
                    || item.FileType == ".bmp" || item.FileType == ".dib"
                    || item.FileType == ".wdp")
                    allPictures.Add(item);
            }

            // Pluck off meta data from pictures
            GetInformationPictures(allPictures);
        }

        private async Task DeleteFolderRecursivelyAsync(StorageFolder folder)
        {
            IReadOnlyList<StorageFolder> folders = await folder.GetFoldersAsync();
            if (folders.Count > 0)
            {
                foreach (StorageFolder subFolder in folders)
                {
                    await DeleteFolderRecursivelyAsync(subFolder);
                }
            }

            IReadOnlyList<StorageFile> files = await folder.GetFilesAsync();
            foreach (StorageFile file in files)
            {
                await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
            }
        }