C# IFolder.GetFilesAsync方法代码示例

        internal FileCache(string cacheToken)
        {
            _cacheToken = cacheToken;
            _folder = FileSystem.Current.LocalStorage.CreateFolderAsync(_cacheToken, CreationCollisionOption.OpenIfExists).Result;
            _httpClient =  new HttpClient(new HttpClientHandler() { AllowAutoRedirect = true, CookieContainer = Client.CookieContainer, UseCookies = true });
            _cachedFiles = new Dictionary<string, string>();

            IList<IFile> files = _folder.GetFilesAsync().Result;

            foreach(IFile file in files)
            {
                _cachedFiles.Add(file.Name, file.Path);
            }
        }

 public static async Task<long> DirSize(IFolder d, Func<string, long> GetFolderSize, Func<string, long> GetFileSize)
 {
     long Size = 0;
     // Add file sizes.
     IList<IFile> fis = await d.GetFilesAsync();
     foreach (IFile fi in fis)
     {
         Size += GetFileSize(fi.Path);
     }
     // Add subdirectory sizes.
     IList<IFolder> fols = await d.GetFoldersAsync();
     foreach (IFolder fo in fols)
     {
         Size += GetFolderSize(fo.Path);
     }
     return (Size);
 }

        private async Task<string> RollingLogFileNameAsync(IFolder folder)
        {
            var files = await folder.GetFilesAsync().ConfigureAwait(false);

            var counter = 0;
            if (files.Count > 0)
            {
                var logFiles = (from f in files where Regex.Match(f.Name, LOG_FILE_PATTERN).Success select f).OrderBy(f => f.Name).ToList();

                if (logFiles.Count > 0)
                {
                    //if the number of files are greater than the max number of files allowed then,
                    //delete the oldest file. oldest file is the file with the lowest number
                    while (logFiles.Count > MAX_FILES_COUNT)
                    {
                        await logFiles[0].DeleteAsync().ConfigureAwait(false);

                        logFiles.RemoveAt(0);
                    }

                    // the current file is the file at the zeroth index.
                    var currentFile = logFiles[logFiles.Count - 1];

                    long fileSize = 0;
                    using (var stream = await currentFile.OpenAsync(PCLStorage.FileAccess.Read).ConfigureAwait(false))
                    {
                        fileSize = stream.Length;
                    }

                    if (fileSize < MAX_SIZE)
                    {
                        return currentFile.Name;
                    }
                    else
                    {
                        var fileName = currentFile.Name;
                        var regex = new Regex(LOG_FILE_PATTERN);
                        var match = regex.Match(fileName);
                        if (match.Success)
                        {
                            if (int.TryParse(match.Groups["counter"].Value, out counter))
                                counter++;
                        }
                    }
                }
            }

            return string.Format(LOG_FILE_FORMAT, counter);
        }

 private async Task<IEnumerable<Event>> GetEvents(IFolder collectionFolder)
 {
     var files = await collectionFolder.GetFilesAsync();
     var fileContents = await TaskEx.WhenAll(files.Select(file => file.ReadAllTextAsync()));
     return fileContents.Select(fc => new Event(fc));
 }

 private async Task<IEnumerable<TopicData>> IndexFilesAsync(IFolder folder)
 {
     var files = await folder.GetFilesAsync(cancellationToken);
     return files.Where(IsTopic)
         .Select(CreateTopicData);
 }