async void LoadStudentDetails() { // Check to see if file exists //Get local storage folder StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; //create a file query StorageFileQueryResult fileResults = storageFolder.CreateFileQuery(); //Get all files in the directory IReadOnlyList <StorageFile> fileList = await fileResults.GetFilesAsync(); //check to see if we have a file studentsFile = fileList.SingleOrDefault(file => file.Name == "students.txt"); if (studentsFile == null) { //if not create studentsFile = await storageFolder.CreateFileAsync("students.txt"); } else { //else load from a stream using (StreamReader reader = new StreamReader(await studentsFile.OpenStreamForReadAsync())) { while (!reader.EndOfStream) { string line = reader.ReadLine(); Student student = new Student(); student.parse(line); RegisteredStudents.Add(student); } } } }
/// <summary> /// 扫描本地Music Library的所有音乐 /// </summary> /// <returns>返回所有的音乐文件属性和相对music library的路径</returns> public static async Task <List <MusicPropertiesWithPath> > ScanLocalMusicInLibrary() { StorageFolder folder = KnownFolders.MusicLibrary; List <MusicPropertiesWithPath> songs = new List <MusicPropertiesWithPath>(); StorageFileQueryResult query = folder.CreateFileQuery(CommonFileQuery.OrderByMusicProperties); //var files = await folder.GetFilesAsync(Windows.Storage.Search.CommonFileQuery.OrderByMusicProperties); var files = await query.GetFilesAsync(); foreach (var file in files) { var properties = await file.Properties.GetMusicPropertiesAsync(); try { using (var stream = await file.OpenReadAsync()) { songs.Add(new MusicPropertiesWithPath() { DefinedProperties = properties, FileName = file.Path.Substring(file.Path.IndexOf("Music")).Remove(0, 6) }); } } catch (Exception ex) { } } return(songs); }
public async Task Initialize(ICamera camera, IStorage storage) { this.camera = camera; this.storage = storage; var cacheFolder = KnownFolders.PicturesLibrary; this.dropFolder = await cacheFolder.GetFolderAsync("securitysystem-cameradrop"); this.dropFolderWatcher = dropFolder.CreateFileQuery(); var images = await this.dropFolderWatcher.GetFilesAsync(); var orderedImages = images.OrderByDescending(x => x.DateCreated); this.newestImage = orderedImages.FirstOrDefault(); this.dropFolderWatcher.ContentsChanged += DropFolderWatcher_ContentsChanged; this.allJoynBusAttachment = new AllJoynBusAttachment(); this.producer = new SecuritySystemProducer(this.allJoynBusAttachment); this.allJoynBusAttachment.AboutData.DefaultAppName = Package.Current.DisplayName; this.allJoynBusAttachment.AboutData.DefaultDescription = Package.Current.Description; this.allJoynBusAttachment.AboutData.DefaultManufacturer = Package.Current.Id.Publisher; this.allJoynBusAttachment.AboutData.SoftwareVersion = Package.Current.Id.Version.ToString(); this.allJoynBusAttachment.AboutData.IsEnabled = true; this.producer.Service = this; this.producer.Start(); }
private async Task <long> GetFolderSizeAsync() { var getFileSizeTasks = from file in await folder.CreateFileQuery().GetFilesAsync() select file.GetBasicPropertiesAsync().AsTask(); var fileSizes = await Task.WhenAll(getFileSizeTasks); return(fileSizes.Sum(i => (long)i.Size)); }
/// <summary> /// Calculates the size of the "Logs" folder. /// </summary> /// <returns>Returns the "Logs" folder size in KB.</returns> public static async Task <long> getLogFolderSizeAsync() { StorageFolder logsFolder = await getLogFolderAsync(); StorageFileQueryResult result = logsFolder.CreateFileQuery(); var fileSizeTasks = (await result.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size); var sizes = await Task.WhenAll(fileSizeTasks); return(sizes.Sum(l => (long)l) / 1024); }
//--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- /// <summary> /// Calculates the size of the "cachedImages" folder. /// </summary> /// <returns>Returns the "cachedImages" folder size in KB.</returns> public async Task <long> getCachedImagesFolderSizeAsync() { StorageFolder f = await getCachedImagesFolderAsync(); StorageFileQueryResult result = f.CreateFileQuery(CommonFileQuery.OrderByName); var fileSizeTasks = (await result.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size); var sizes = await Task.WhenAll(fileSizeTasks); return(sizes.Sum(l => (long)l) / 1024); }
public static async Task GetWallpaperStorageFile(StorageFolder folder, string name) { var query = folder.CreateFileQuery(); var files = await query.GetFilesAsync(); foreach (StorageFile file in files) { var fileName = file.Name.ToString(); if (fileName.Contains(name)) { await ApplyImagetoWallpaperAsync(file); } } }
public async Task <IEnumerable <MenuCard> > ReadMenuCardsAsync() { List <MenuCard> menuCards = new List <MenuCard>(); StorageFolder folder = ApplicationData.Current.RoamingFolder; StorageFileQueryResult result = folder.CreateFileQuery(); var queryOptions = new QueryOptions(); queryOptions.IndexerOption = IndexerOption.DoNotUseIndexer; queryOptions.FolderDepth = FolderDepth.Shallow; queryOptions.FileTypeFilter.Add(".xml"); result.ApplyNewQueryOptions(queryOptions); IReadOnlyList <StorageFile> files = await result.GetFilesAsync(); foreach (var file in files) { using (Stream stream = await file.OpenStreamForReadAsync()) { try { var serializer = new DataContractSerializer(typeof(MenuCardData)); object data = await Task <object> .Run(() => serializer.ReadObject(stream)); //var serializer = new XmlSerializer(typeof(MenuCardData)); //object data = await Task<object>.Run(() => serializer.Deserialize(stream)); MenuCard menuCard = (data as MenuCardData).ToMenuCard(); menuCard.RestoreReferences(); menuCards.Add(menuCard); } catch (Exception) { // TODO: log exception } } } // read images MenuCardImageStorage imageStorage = new MenuCardImageStorage(); foreach (var menuCard in menuCards) { if (menuCard.ImagePath != null) { menuCard.Image = await imageStorage.ReadImageAsync(menuCard.ImagePath); } } return(menuCards); }
//https://docs.microsoft.com/en-us/uwp/api/windows.storage.storagefolder //https://stackoverflow.com/questions/45866872/get-all-files-inside-a-specific-folder-in-a-library-with-uwp //Péter Bozsó private async void BuildVideoList() { videoList.Items.Clear(); this.playButton.IsEnabled = false; StorageFolder storageFolder = await currentFolder.GetFolderAsync(playList.SelectedItem.ToString()); StorageFileQueryResult results = storageFolder.CreateFileQuery(); IReadOnlyList <StorageFile> filesInFolder = await results.GetFilesAsync(); foreach (StorageFile item in filesInFolder) { string name = item.Name; name = name.Substring(0, name.Length - 4); videoList.Items.Add(name); } }
/// <summary> /// Get a list of names of files whose filename ends with the specified extension /// </summary> /// <param name="storageFolder">Folder to be searched</param> /// <param name="extension">File extension (e.g. .txt)</param> /// <returns>List of names of files in the specified folder which end with the specified extension</returns> public static async Task <List <string> > GetDocumentFilesOfTypeFromFolder(StorageFolder storageFolder, string extension) { var results = new List <string>(); try { var queryResult = storageFolder.CreateFileQuery(); var files = await queryResult.GetFilesAsync(); results.AddRange(from file in files where file.Name.ToLower().EndsWith(extension.ToLower()) select file.Name); } catch (Exception) { results = null; } return(results); }
private static async Task <IList <IStorageFile> > GetAllFilesAsync(this StorageFolder folder, QueryOptions options = null, List <IStorageFile> files = null) { files = files ?? new List <IStorageFile>(); var subFolders = await folder.GetFoldersAsync(); foreach (var subfolder in subFolders) { await GetAllFilesAsync(subfolder, options, files); } var query = options == null?folder.CreateFileQuery() : folder.CreateFileQueryWithOptions(options); var folderFiles = await query.GetFilesAsync(); files.AddRange(folderFiles); return(files); }
private async void GetFilesButton_Click(object sender, RoutedEventArgs e) { // Reset output. OutputPanel.Children.Clear(); // Ask the user to pick a folder. FolderPicker picker = new FolderPicker(); picker.FileTypeFilter.Add("*"); picker.ViewMode = PickerViewMode.List; picker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary; StorageFolder folder = await picker.PickSingleFolderAsync(); if (folder != null) { // Query the folder. var query = folder.CreateFileQuery(); var fileList = await query.GetFilesAsync(); // Display file list with storage provider and availability. foreach (StorageFile file in fileList) { // Create an entry in the list for the item. var line = file.Name; // Show the item's provider (This PC, SkyDrive, Network, or Application Content). line += ": On " + file.Provider.DisplayName; // Show if the item is available (SkyDrive items are usually available when // online or when they are marked for "always available offline"). line += " ("; if (file.IsAvailable) { line += "available"; } else { line += "not available"; } line += ")"; OutputPanel.Children.Add(CreateLineItemTextBlock(line)); } } }
public static async Task <int> CalculateSize(this StorageFolder folder) { // Query all files in the folder. Make sure to add the CommonFileQuery // So that it goes through all sub-folders as well var folders = folder.CreateFileQuery(CommonFileQuery.OrderByName); // Await the query, then for each file create a new Task which gets the size var fileSizeTasks = (await folders.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size); // Wait for all of these tasks to complete. WhenAll thankfully returns each result // as a whole list var sizes = await Task.WhenAll(fileSizeTasks); // Sum all of them up. You have to convert it to a long because Sum does not accept ulong. long size = sizes.Sum(l => (long)l); double d = (Convert.ToDouble(size) / 1024) / 1024; return(Convert.ToInt32(d)); }
/////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Get the names of all the files in the default folder for this app /// </summary> /// <returns>List of all the files in this app's root folder</returns> /////////////////////////////////////////////////////////////////////////////////// public static async Task <List <string> > GetDocumentFiles() { List <string> results = new List <string>(); try { StorageFolder storageFolder = ApplicationData.Current.LocalFolder; StorageFileQueryResult queryResult = storageFolder.CreateFileQuery(); var files = await queryResult.GetFilesAsync(); foreach (StorageFile file in files) { results.Add(file.Name); } } catch (Exception ex) { results = null; } return(results); }
private async Task <bool> checkIfToDoTasksFileIsPresent() { bool fileExists = false; var query = localFolder.CreateFileQuery(); var listOfFiles = await query.GetFilesAsync(); if (listOfFiles.Count > 0) { foreach (var file in listOfFiles) { if (file.Name == "ToDoTasks.txt") { fileExists = true; break; } } } return(fileExists); }
/////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Get a list of names of files whose filename ends with the specified extension /// </summary> /// <param name="storageFolder">Folder to be searched</param> /// <param name="extension">File extension (e.g. .txt)</param> /// <returns>List of names of files in the specified folder which end with the specified extension</returns> /////////////////////////////////////////////////////////////////////////////////// public static async Task <List <string> > GetDocumentFilesOfTypeFromFolder(StorageFolder storageFolder, string extension) { List <string> results = new List <string>(); try { StorageFileQueryResult queryResult = storageFolder.CreateFileQuery(); var files = await queryResult.GetFilesAsync(); foreach (StorageFile file in files) { if (file.Name.ToLower().EndsWith(extension.ToLower())) { results.Add(file.Name); } } } catch (Exception ex) { results = null; } return(results); }
private async void playList_ItemClick(object sender, ItemClickEventArgs e) { videoList.Items.Clear(); this.playButton.IsEnabled = false; try { StorageFolder storageFolder = await currentFolder.GetFolderAsync(e.ClickedItem.ToString()); StorageFileQueryResult results = storageFolder.CreateFileQuery(); IReadOnlyList <StorageFile> filesInFolder = await results.GetFilesAsync(); foreach (StorageFile item in filesInFolder) { string name = item.Name; name = name.Substring(0, name.Length - 4); videoList.Items.Add(name); } } catch (Exception exception) { BuildPlaylists(); } }
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 async Task CalcFolderSizeAsync(string path) { if (!(calcSizeCancelToken is null)) { calcSizeCancelToken.Cancel(); } calcSizeCancelToken = new CancellationTokenSource(); if (!(calcSizeTask is null)) { await calcSizeTask; } Text = "Calculating size..."; long size = 0; calcSizeTask = Task.Run(async() => { try { StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(path); if (!(folder is null)) { StorageFileQueryResult result = folder.CreateFileQuery(CommonFileQuery.OrderByName); var fileSizeTasks = (await result.GetFilesAsync()).Select(async file => (await file.GetBasicPropertiesAsync()).Size); var fileSizes = await Task.WhenAll(fileSizeTasks); // Sum up and convert to kilo byte: size = fileSizes.Sum(l => (long)l) / 1024; } } catch (FileNotFoundException e) { Logger.Error("Failed to calculate folder size for path: " + path, e); Text = "Invalid path!"; } catch (Exception e) { Logger.Error("Failed to calculate folder size for path: " + path, e); } }, calcSizeCancelToken.Token); await calcSizeTask; if (calcSizeCancelToken is null || calcSizeCancelToken.IsCancellationRequested) { return; } StringBuilder sb = new StringBuilder("~ "); if (size >= 1024) { sb.Append(size / 1024); sb.Append(" MB"); } else { sb.Append(size); sb.Append(" KB"); } Text = sb.ToString(); }