C# Bundle.EnumerateFiles方法代码示例

        /// <summary>
        ///     Returns virtual paths of included files in <paramref name="virtualPath" />  file, according to
        ///     <paramref name="context" />.
        ///     If not added yet and <see cref="LessTransform" /> included in bundle transforms, executes
        ///     <see cref="LessTransform" /> transformation for the specified <paramref name="bundle" />
        ///     and ensures the dependencies are saved.
        /// </summary>
        /// <param name="bundle">Bundle to process, if not yet</param>
        /// <param name="virtualPath">Root  file to get dependencies for.</param>
        /// <param name="context">Current context.</param>
        /// <returns>Virtual paths of included files.</returns>
        private static IEnumerable<string> GetFileDependencies(Bundle bundle, string virtualPath, BundleContext context)
        {
            string key = BundleTable.VirtualPathProvider.GetCacheKey(virtualPath) ?? virtualPath;

            Func<string, IList<string>> process;

            if (bundle.Transforms.Any(transform => transform is LessTransform))
            {
                process = s =>
                {
                    IEnumerable<BundleFile> files = bundle.EnumerateFiles(context);
                    LessTransform.Process(ref files);
                    return files.Select(file => file.IncludedVirtualPath).ToArray();
                };
            }
            else
            {
                process = s => new string[0];
            }

            _fileDependencies.GetOrAdd(key, process);

            // returns more specific dependencies by the key containing transient file paths
            return _fileDependencies.GetOrAdd(GetTransientFileKey(virtualPath), process);
        }

		private BundleResponse GetSingleFileBundleResponse(Bundle bundle, BundleContext bundleContext, string filepath)
		{
			var files = bundle.EnumerateFiles(bundleContext);
			var file = files.FirstOrDefault(f => f.VirtualFile.VirtualPath.TrimStart(new[] { '/' }) == filepath);

			if (file == null)
			{
				throw new FileNotFoundException(string.Format("File not found '{0}'", filepath));
			}

			string contents;
			var virtualPathProvider = HostingEnvironment.VirtualPathProvider;
			var virtualFile = virtualPathProvider.GetFile(VirtualPathUtility.ToAppRelative(file.VirtualFile.VirtualPath));
			using (var streamReader = new StreamReader(virtualFile.Open()))
			{
				contents = streamReader.ReadToEnd();
			}

			return bundle.ApplyTransforms(bundleContext, contents, new List<BundleFile> { file });
		}

		private static string GetTimeStamp(Bundle bundle, BundleContext bundleContext)
		{
			var lastdate = DateTime.MinValue;
			foreach (var file in bundle.EnumerateFiles(bundleContext))
			{
				var mappedPath = HostingEnvironment.MapPath(file.IncludedVirtualPath);
				if (mappedPath != null && File.Exists(mappedPath))
				{
					var fileDate = File.GetLastWriteTime(mappedPath);
					if (fileDate > lastdate)
					{
						lastdate = fileDate;
					}
				}
			}

			return lastdate.ToString("yyyyMMddHHmmss");
		}