C# StorageFolder.CreateFileQueryWithOptions方法代碼示例

		private async void BrowseButton_Click(object sender, RoutedEventArgs e)
		{
			try
			{
				var folderPicker = new FolderPicker()
				{
					CommitButtonText = "Open",
					SuggestedStartLocation = PickerLocationId.DocumentsLibrary,
					ViewMode = PickerViewMode.List
				};
				folderPicker.FileTypeFilter.Add(".shp");

				_folder = await folderPicker.PickSingleFolderAsync();
				if (_folder != null)
				{
					var qopts = new QueryOptions(CommonFileQuery.OrderByName, new string[] { ".shp" });
					var query = _folder.CreateFileQueryWithOptions(qopts);
					var files = await query.GetFilesAsync();
					FileListCombo.ItemsSource = files;
					FileListCombo.Visibility = (files.Any()) ? Visibility.Visible : Visibility.Collapsed;
				}
			}
			catch (Exception ex)
			{
				var _ = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
			}
		}

        private async void GetAllVideos(StorageFolder KnownFolders, QueryOptions QueryOptions)
        {
            StorageFileQueryResult query = KnownFolders.CreateFileQueryWithOptions(QueryOptions);
            IReadOnlyList<StorageFile> folderList = await query.GetFilesAsync();

            // Get all the videos in the folder past in parameter
            int id = 0;
            foreach (StorageFile file in folderList)
            {
                using (StorageItemThumbnail thumbnail = await file.GetThumbnailAsync(ThumbnailMode.VideosView, 200, ThumbnailOptions.UseCurrentScale))
                {
                    // Get video's properties
                    VideoProperties videoProperties = await file.Properties.GetVideoPropertiesAsync();

                    BitmapImage VideoCover = new BitmapImage();
                    VideoCover.SetSource(thumbnail);

                    Video video = new Video();
                    video.Id = id;
                    video.Name = file.Name;
                    video.DateCreated = file.DateCreated.UtcDateTime;
                    video.FileType = file.FileType;
                    video.VideoPath = file.Path;
                    video.Duration = videoProperties.Duration;
                    video.VideoFile = file;
                    video.VideoCover = VideoCover;

                    // Add the video to the ObservableCollection
                    Videos.Add(video);
                    id++;
                }
            }
        }

        public static async Task<List<StorageFile>> LoadFolderFiles(StorageFolder storageFolder)
        {
            var queryOptions = new QueryOptions
                       (
                       CommonFileQuery.OrderByName, new List<string> { ".3g2", ".3gp2", ".3gp", ".3gpp", ".m4a", ".m4v", ".mp4v", ".mp4", ".mov", ".m2ts", ".asf", ".wm", ".vob", ".wmv", ".wma", ".aac", ".adt", ".mp3", ".wav", ".avi", ".ac3", ".ec3" }
                       );

            var fileQuery = storageFolder.CreateFileQueryWithOptions(queryOptions);

            var ass = await fileQuery.GetFilesAsync();

            return ass.ToList();
        }

        private async Task<ulong> GetFolderSize(StorageFolder folder) {
            StorageFileQueryResult query = folder.CreateFileQueryWithOptions(new QueryOptions {
                FolderDepth = FolderDepth.Deep
            });

            IReadOnlyList<StorageFile> files = await query.GetFilesAsync();
            ulong size = 0;
            foreach (StorageFile file in files) {
                BasicProperties props = await file.GetBasicPropertiesAsync();
                size += props.Size;
            }

            return size;
        }

 /// <param name="filter">".jpg"</param>
 public async Task<List<Models.ImageInfo>> ThumbnailsAsync(StorageFolder folder, uint requestedSize = 190, params string[] filter)
 {
     var options = new QueryOptions(CommonFileQuery.OrderByName, filter);
     var query = folder.CreateFileQueryWithOptions(options);
     var files = (await query.GetFilesAsync() as IReadOnlyList<StorageFile>).ToList();
     var scale = ThumbnailOptions.UseCurrentScale;
     var mode = ThumbnailMode.PicturesView;
     var result = new List<Models.ImageInfo>();
     foreach (var file in files)
     {
         var thumbnail = await file.GetThumbnailAsync(mode, requestedSize, scale);
         result.Add(new Models.ImageInfo { File = file, Thumbnail = thumbnail });
     }
     return result;
 }

 // Set functionality for the folder
 public async Task SetFolder(StorageFolder folder)
 {
     //unhook the old contents changed event if applicable
     if (_queryResult != null)
     {
         _queryResult.ContentsChanged -= QueryResult_ContentsChanged;
     }
     // Initialize the query and register for changes
     _folder = folder;
     QueryOptions options = new QueryOptions();
     // options.IndexerOption = IndexerOption.DoNotUseIndexer;
     _queryResult = _folder.CreateFileQueryWithOptions(options);
     _queryResult.ContentsChanged += QueryResult_ContentsChanged;
     await UpdateCount();
 }

 public WatchedFolder(StorageFolder folder)
 {
     _folder = folder;
     _fileQueryResult = _folder.CreateFileQueryWithOptions(_queryOptions);
     _fileQueryResult.ContentsChanged += _fileQueryResult_ContentsChanged;
 }

        /// <summary>
        /// Generates html for the gallery
        /// </summary>
        /// <param name="folder">Folder to read the pictures from</param>
        /// <param name="pageNumber">Page starting from 1</param>
        /// <param name="pageSize">Number of pictures on each page</param>
        /// <returns></returns>
        public async Task<string> GenerateGallery(StorageFolder folder, int pageNumber, int pageSize)
        {
            // Don't allow negatives
            if (pageNumber < 1) pageNumber = 1;
            if (pageSize < 1) pageSize = 1;

            var subFolders = await folder.GetFoldersAsync();
            var parentFolder = await folder.GetParentAsync();

            // JavaScript code for toggling the subfolder list
            string html = "";
            html += "<script type='text/javascript'>" +
                "function toggleSubfolderList(){"+
                "var folderNavPane = document.getElementById('folder_nav_pane');" +
                "if(folderNavPane.style.display == 'block') folderNavPane.style.display = 'none';" +
                "else folderNavPane.style.display = 'block'" +
                "}" +
                "</script>";

            html += "<table>";
            html += "<tr><td>";
            // Create breadcrumbs for folder nav
            var temp = folder;
            string breadcrumbs = "<b>"+ ((subFolders.Count > 0) ? "<a onclick='toggleSubfolderList()' href='javascript:void(0);'>" + temp.Name + "</a>" : temp.Name) + "</b>";
            while(!temp.Path.Equals(rootFolder.Path, StringComparison.OrdinalIgnoreCase))
            {
                temp = await temp.GetParentAsync();
                string hyperlink = MakeHyperlink(temp.Name, "/gallery.htm?folder=" + WebUtility.UrlEncode(temp.Path), false);
                breadcrumbs = hyperlink + " > " + breadcrumbs;
            }
            html += breadcrumbs + "<br>";

            if (subFolders.Count > 0)
            {
                // Generate subfolder navigation pane
                html += "<div id='folder_nav_pane' style='display:none'>";
                html += "<ul>";
                foreach (StorageFolder subFolder in subFolders)
                {
                    html += "<li><a href='/gallery.htm?folder=" + WebUtility.UrlEncode(subFolder.Path) + "'>" + subFolder.Name + "</a></li>";
                }
                html += "</ul></div>";
            }

            html += "<br></td></tr>";

            // Get the files in current folder and subfolders
            var queryOptions = new QueryOptions();
            queryOptions.FolderDepth = FolderDepth.Deep;

            var results = folder.CreateFileQueryWithOptions(queryOptions);
            
            StorageFile[] sortedFiles = null;

            // Use cached files if we already got the files and we're navigating to the first page
            if (cachedFiles != null && pageNumber != 1)
            {
                sortedFiles = cachedFiles;
            }
            else
            {
                var files = await results.GetFilesAsync();
                sortedFiles = files.OrderByDescending((x) => x.DateCreated).ToArray();
                cachedFiles = sortedFiles;
            }

            if (sortedFiles.Length > 0)
            {
                // Create pages
                string pagesHtml = "<form>";
                html += "<tr><td>";
                int totalPages = (int)Math.Ceiling((double)sortedFiles.Length / pageSize);
                pagesHtml += "Pages: ";

                pagesHtml += "<select name='page' onchange='this.form.submit()'>";

                for (int i = 1; i <= totalPages; i++)
                {
                    pagesHtml += "<option value='" + i + "' " + ((i == pageNumber) ? "selected='selected'" : "") + ">" + i + "</option>";
                }
                pagesHtml += "</select>";
                pagesHtml += "<input type='hidden' name='folder' value='" + folder.Path + "' />";
                pagesHtml += "<input type='hidden' name='pageSize' value='30' />";
                pagesHtml += "</form>";

                html += pagesHtml;
                html += "<br></td></tr>";

                html += "<tr><td>";

                // Pick out the subset of files we need based on page
                int startIndex = (pageNumber - 1) * pageSize;
                for (int i = startIndex; i < startIndex + pageSize; i++)
//.........這裏部分代碼省略.........

        /// <summary>
        /// 
        /// </summary>
        public async void RefreshQueue()
        {
            try
            {
                reportFolder = await KnownFolders.DocumentsLibrary.CreateFolderAsync("311_Reports_Folder", CreationCollisionOption.OpenIfExists);
            }
            catch (Exception) { /*NotifyUser("DOCUMENT ERROR", NotifyType.ReportMessage);*/ }

            try
            {
                pictureFolder = await KnownFolders.PicturesLibrary.CreateFolderAsync("311_Pictures_Folder", CreationCollisionOption.OpenIfExists);
            }
            catch (Exception) { /*NotifyUser("PICTURE ERROR", NotifyType.ReportMessage);*/ }

            var queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, new[] { ".txt" });
            var query = reportFolder.CreateFileQueryWithOptions(queryOptions);
            var report_files = await query.GetFilesAsync();

            queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, new[] { ".png" });
            query = pictureFolder.CreateFileQueryWithOptions(queryOptions);
            var picture_files = await query.GetFilesAsync();

            //if (report_files.Count != picture_files.Count)
            //{
            //   await RemoveQueue(true);
            //}

            if ((queuedReportCount = report_files.Count) > 0)
            {
                ShowQueue(report_files, picture_files);
            }
            else
            {
                QueuedListView.Items.Clear();
                queuedListIndex.Clear();
            }
        }

        /// <summary>
        /// Finds and displays the first image file on the storage.
        /// </summary>
        /// <param name="storage"></param>
        async private Task GetFirstImageFromStorageAsync(StorageFolder storage)
        {
            var storageName = storage.Name;

            // Construct the query for image files
            var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, new List<string> { ".jpg", ".png", ".gif" });
            var imageFileQuery = storage.CreateFileQueryWithOptions(queryOptions);

            // Run the query for image files
            rootPage.NotifyUser("[Launched by Autoplay] Looking for images on " + storageName + " ...", NotifyType.StatusMessage);
            var imageFiles = await imageFileQuery.GetFilesAsync();
            if (imageFiles.Count > 0)
            {
                var imageFile = imageFiles[0];
                rootPage.NotifyUser("[Launched by Autoplay] Found " + imageFile.Name + " on " + storageName, NotifyType.StatusMessage);
                await DisplayImageAsync(imageFile);
            }
            else
            {
                rootPage.NotifyUser("[Launched by Autoplay] No images were found on " + storageName + ". You can use scenario 2 to transfer an image to it", NotifyType.StatusMessage);
            }
        }

        private static async Task<IReadOnlyList<StorageFile>> GetMediaFromFolder(StorageFolder folder,
                                                                            CommonFileQuery query)
        {
            IReadOnlyList<StorageFile> files = null;
            StorageFileQueryResult fileQuery;
            var queryOptions = new QueryOptions(query,
                                               new List<string>
                                               {
                                                   ".3g2",
                                                   ".3gp",
                                                   ".3gp2",
                                                   ".3gpp",
                                                   ".amv",
                                                   ".asf",
                                                   ".avi",
                                                   ".divx",
                                                   ".drc",
                                                   ".dv",
                                                   ".f4v",
                                                   ".flv",
                                                   ".gvi",
                                                   ".gxf",
                                                   ".ismv",
                                                   ".iso",
                                                   ".m1v",
                                                   ".m2v",
                                                   ".m2t",
                                                   ".m2ts",
                                                   ".m3u8",
                                                   ".mkv",
                                                   ".mov",
                                                   ".mp2",
                                                   ".mp2v",
                                                   ".mp4",
                                                   ".mp4v",
                                                   ".mpe",
                                                   ".mpeg",
                                                   ".mpeg1",
                                                   ".mpeg2",
                                                   ".mpeg4",
                                                   ".mpg",
                                                   ".mpv2",
                                                   ".mts",
                                                   ".mtv",
                                                   ".mxf",
                                                   ".mxg",
                                                   ".nsv",
                                                   ".nut",
                                                   ".nuv",
                                                   ".ogm",
                                                   ".ogv",
                                                   ".ogx",
                                                   ".ps",
                                                   ".rec",
                                                   ".rm",
                                                   ".rmvb",
                                                   ".tob",
                                                   ".ts",
                                                   ".tts",
                                                   ".vob",
                                                   ".vro",
                                                   ".webm",
                                                   ".wm",
                                                   ".wmv",
                                                   ".wtv",
                                                   ".xesc",
                                               });

            try
            {
                fileQuery = folder.CreateFileQueryWithOptions(queryOptions);

                files = await fileQuery.GetFilesAsync();
            }
            catch (Exception ex)
            {
                Debug.WriteLine("exception listing files");
                Debug.WriteLine(ex.ToString());
            }
            // DLNA folders don't support advanced file listings, us a basic file query
            if (files == null)
            {
                fileQuery = folder.CreateFileQuery(CommonFileQuery.OrderByName);
                files = await fileQuery.GetFilesAsync();
            }

            return files;
        }

 private StorageFileQueryResult getResourceFilePaths(StorageFolder folder, IEnumerable<string> fileTypeFilters)
 {
     QueryOptions queryOptions = new QueryOptions(CommonFileQuery.OrderByName, fileTypeFilters);
     queryOptions.FolderDepth = FolderDepth.Deep;
     return folder.CreateFileQueryWithOptions(queryOptions);
 }

        private async Task AddFiles(StorageFolder parentFolder)
        {
            var fileQuery = parentFolder.CreateFileQueryWithOptions(
                new QueryOptions(Windows.Storage.Search.CommonFileQuery.OrderByDate, new string[] { ".jpg", ".png" })
                );

            //Find up to 250 pictures in all sub folders of the parent folder

            var files = await fileQuery.GetFilesAsync(0, 250);

            foreach (var file in files)
            {
                string fileType = file.FileType.ToLowerInvariant();
                switch (fileType)
                {
                    case ".jpg":
                    case ".png":
                        lock (_allUris)
                        {
                            if (_allUris.Count >= MaxPhotos)
                            {
                                return;
                            }

                            string pathname = file.Path;
                            Uri uri = new Uri(pathname, UriKind.Absolute);
                            _allUris.Add(uri);
                        }
                        break;
                }
            }
        }