private string[] _GetDependencies(VirtualFile virtualFile) { var dir = VirtualPathUtility.GetDirectory(virtualFile.VirtualPath); string content; using (var stream = virtualFile.Open()) using (var reader = new StreamReader(stream)) content = reader.ReadToEnd(); return _ReferenceRegex.Matches(content).Cast<Match>().Select(m => { var relativePath = m.Groups["path"].Value; return VirtualPathUtility.Combine(dir, relativePath); }).Where(m => this.ExcludedDependencies.All(e => !m.Contains(@"/" + e))).ToArray(); }
private ContentRegistration AnalyzeView(HttpContextBase httpContext, VirtualFile file, string controllerName, Type modelType, List<ContentRegistration> registrations) { if (modelType == null || !typeof(ContentItem).IsAssignableFrom(modelType) || modelType.IsAbstract) return null; var model = Activator.CreateInstance(modelType) as ContentItem; var rd = new RouteData(); var isPage = model != null && model.IsPage; RouteExtensions.ApplyCurrentPath(rd, controllerName, Path.GetFileNameWithoutExtension(file.Name), new PathData(isPage ? model : new StubItem(), isPage ? null : model)); var cctx = new ControllerContext(httpContext, rd, new StubController()); var result = isPage ? viewEnginesProvider.Get().FindView(cctx, file.VirtualPath, null) : viewEnginesProvider.Get().FindPartialView(cctx, file.VirtualPath); return result.View == null ? null : RenderViewForRegistration(file, modelType, cctx, result, registrations); }
private string GetPageTitle(VirtualFile file) { string aspx; using (var infile = file.Open()) { using (var reader = new StreamReader(infile)) { aspx = reader.ReadToEnd(); } } var m = titleRegex.Match(aspx); if (m.Success && m.Groups.Count > 1) { return m.Groups[1].Value; } else { return VirtualPathUtility.GetFileName(file.VirtualPath); } }
private ContentRegistration RenderViewForRegistration(VirtualFile file, Type modelType, ControllerContext cctx, ViewEngineResult result) { var re = new ContentRegistration(map.CreateDefinition(modelType, N2.Web.Url.RemoveAnyExtension(file.Name))); re.IsDefined = false; re.Context.TouchedPaths.Add(file.VirtualPath); using (StringWriter sw = new StringWriter()) { var vdd = new ViewDataDictionary(); cctx.Controller.ViewData = vdd; N2.Web.Mvc.Html.RegistrationExtensions.SetRegistrationExpression(cctx.HttpContext, re); try { logger.DebugFormat("Rendering view {0} for registrations", file.VirtualPath); result.View.Render(new ViewContext(cctx, result.View, vdd, new TempDataDictionary(), sw), sw); logger.DebugFormat("Rendered view {0}, editables = {1}, defined = {2}", file.VirtualPath, re.Definition.Editables.Count, re.IsDefined); } catch (Exception ex) { logger.Error(file.VirtualPath, ex); if (re.IsDefined) throw; return null; } finally { N2.Web.Mvc.Html.RegistrationExtensions.SetRegistrationExpression(cctx.HttpContext, null); } if (re.IsDefined) { return re; } return null; } }
internal void TransmitFile (VirtualFile vf) { TransmitFile (vf, false); }
private ViewTemplateDescription RenderViewForRegistration(VirtualFile file, Type modelType, ControllerContext cctx, ViewEngineResult result) { var re = new ContentRegistration(); re.ContentType = modelType; re.Template = N2.Web.Url.RemoveAnyExtension(file.Name); re.IsDefined = false; using (StringWriter sw = new StringWriter()) { var vdd = new ViewDataDictionary(); cctx.Controller.ViewData = vdd; vdd["RegistrationExpression"] = re; try { result.View.Render(new ViewContext(cctx, result.View, vdd, new TempDataDictionary(), sw), sw); } catch (Exception ex) { Trace.WriteLine(ex); if (re.IsDefined) throw; return null; } if (re.IsDefined) { return new ViewTemplateDescription { Registration = re, Definition = GetOrCreateDefinition(re), TouchedPaths = new[] { file.VirtualPath }.Union(re.TouchedPaths) }; } return null; } }
private static string GetTitle(VirtualFile file) { return Normalize(Path.GetFileNameWithoutExtension(file.VirtualPath)); }
public VirtualPathFile(VirtualFile file) { _file = file; }
public FileViewLocationResult(VirtualFile file, string name) : base(file.VirtualPath, name, () => new StreamReader(VirtualPathProviderHelper.Open(file))) { //_fileHash = VirtualPathProviderHelper.GetFileHash(file.VirtualPath); //this._lastModifiedUtc = file.LastWriteTimeUtc; }
public WebFormVirtualFile(string virtualPath, VirtualFile actualFile, string assemblyDirective) : base(virtualPath) { _actualFile = actualFile; _assemblyDirective = assemblyDirective; }
public static Stream Open(VirtualFile virtualFile) { using (var fs = virtualFile.Open()) { var stream = new MemoryStream(); fs.CopyTo(stream); stream.Position = 0; return stream; } /* using (var fs = File.OpenRead(path)) { var stream = new MemoryStream(); fs.CopyTo(stream); stream.Position = 0; return stream; } * */ }
// support for VirtualPathProvider internal void WriteVirtualFile(VirtualFile vf) { Debug.Trace("WriteVirtualFile", vf.Name); using (Stream s = vf.Open()) { if (UsingHttpWriter) { long size = s.Length; if (size > 0) { // write as memory block byte[] fileBytes = new byte[(int)size]; int bytesRead = s.Read(fileBytes, 0, (int) size); _httpWriter.WriteBytes(fileBytes, 0, bytesRead); } } else { // Write file contents WriteStreamAsText(s, 0, -1); } } }
public virtual void CopyTo(VirtualFile source, String newVirtualPath) { UnifiedFile.CopyTo(source, newVirtualPath); }
public virtual Boolean OnTransmitting(VirtualFile file) { return UnifiedFile.OnTransmitting(file); }
void AddVirtualFile (VirtualFile file, BuildProviderCollection bpcoll) { if (file == null || BuildManager.IgnoreVirtualPath (file.VirtualPath)) return; BuildProvider bp = GetBuildProvider (file.VirtualPath, bpcoll); if (bp == null) return; AddBuildProvider (bp); }
private IEnumerable<string> ReadLines(VirtualFile file) { using(var s = file.Open()) using (var sr = new StreamReader(s)) { while(sr.Peek() >= 0) { yield return sr.ReadLine(); } } }
/// <summary> /// 从指定虚拟文件中读取文本内容 /// </summary> /// <param name="file">虚拟文件</param> /// <returns></returns> public static string LoadContent( VirtualFile file ) { using ( var reader = new StreamReader( file.Open(), true ) ) { return reader.ReadToEnd(); } }
private VirtualFile GetModuleCustomVirtualFile(string virtualPath, VirtualFile actualFile) { var file = GetModuleVirtualOverride(virtualPath); if (file == null) return null; if (Logger.IsEnabled(LogLevel.Debug)) { Logger.Debug("Virtual file from module \"{0}\" served with specific assembly directive:", file.ModuleName); Logger.Debug(" Virtual path: {0}", virtualPath); Logger.Debug(" Assembly directive: {0}", file.Directive); } return new WebFormVirtualFile(virtualPath, actualFile, file.Directive); }
public TestVirtualPathProvider(string path, VirtualFile file) { this.path = path; this.file = file; }
// Copy one file from the source app to the precompiled app private void CopyPrecompiledFile(VirtualFile vfile, string destPhysicalPath) { bool createStub; if (CompilationUtil.NeedToCopyFile(vfile.VirtualPathObject, PrecompilingForUpdatableDeployment, out createStub)) { // string sourcePhysicalPath = HostingEnvironment.MapPathInternal(vfile.VirtualPath); // The file could already exist with updatable precompilation, since we would create the modified file // earlier during processing of a code beside page. if (File.Exists(destPhysicalPath)) { // In that case, we still need to fix it up to insert the correct type string in the // inherits attribute (VSWhidbey 467936) // First, get the just-compiled BuildResult. It should always exist BuildResultCompiledType result = GetVPathBuildResult(null, vfile.VirtualPathObject, true /*noBuild*/, false /*allowCrossApp*/) as BuildResultCompiledType; Debug.Assert(result != null); // VSWhidbey 527299. Need to use the same encoding of the original file to // read and write to the new file. Encoding encoding = Util.GetEncodingFromConfigPath(vfile.VirtualPathObject); // Read in the file string newAspxFile = Util.StringFromFile(destPhysicalPath, ref encoding); // Replace the placeholder token by the true type with the assembly newAspxFile = newAspxFile.Replace(UpdatableInheritReplacementToken, Util.GetAssemblyQualifiedTypeName(result.ResultType)); // Write the modified file back with the correct inherits type string StreamWriter writer = new StreamWriter(destPhysicalPath, false /* append */, encoding); writer.Write(newAspxFile); writer.Close(); } else { // Just copy the file to the destination File.Copy(sourcePhysicalPath, destPhysicalPath, false /*overwrite*/); } // If it has a readonly attribute, clear it on the destination (VSWhidbey 122359) Util.ClearReadOnlyAttribute(destPhysicalPath); } else { if (createStub) { // Create the stub file, with a helpful static message StreamWriter writer = new StreamWriter(destPhysicalPath); writer.Write(SR.GetString(SR.Precomp_stub_file)); writer.Close(); } } }
public void AddFile(VirtualFile file) { FileMap[NormalizeVirtualPath(file.VirtualPath)] = file; }
private static string GetUrl(VirtualFile file) { string dir = VirtualPathUtility.GetDirectory(file.VirtualPath); string filePath = Path.GetFileNameWithoutExtension(file.VirtualPath); return VirtualPathUtility.Combine(dir, filePath).ToLowerInvariant(); }
public VirtualFileWrapper(VirtualFile fileToWrap) { this.UnderlyingFile = fileToWrap; }
/// <summary> /// Gets the file dependencies (@imports) of the LESS file being parsed. /// </summary> /// <param name="lessParser">The LESS parser.</param> /// <param name="virtualFile">The virtual file</param> /// <returns>An array of file references to the dependent file references.</returns> private IEnumerable<BundleFile> GetFileDependencies(Parser lessParser, VirtualFile virtualFile) { var pathResolver = this.GetPathResolver(lessParser); foreach (var importPath in lessParser.Importer.Imports) { yield return new BundleFile(pathResolver.GetFullPath(importPath), virtualFile); } lessParser.Importer.Imports.Clear(); }
internal void WriteVirtualFile(VirtualFile vf) { using (Stream stream = vf.Open()) { if (this.UsingHttpWriter) { long length = stream.Length; if (length > 0L) { byte[] buffer = new byte[(int) length]; int count = stream.Read(buffer, 0, (int) length); this._httpWriter.WriteBytes(buffer, 0, count); } } else { this.WriteStreamAsText(stream, 0L, -1L); } } }
internal void TransmitFile (VirtualFile vf, bool final_flush) { if (vf == null) throw new ArgumentNullException ("vf"); if (vf is DefaultVirtualFile) { TransmitFile (HostingEnvironment.MapPath (vf.VirtualPath), final_flush); return; } byte[] buf = new byte [bufLen]; using (Stream s = vf.Open ()) { int readBytes; while ((readBytes = s.Read (buf, 0, bufLen)) > 0) { output_stream.Write (buf, 0, readBytes); output_stream.ApplyFilter (final_flush); Flush (false); } if (final_flush) Flush (true); } }
public FileToStreamImpl(string path) { path = HttpUtility.UrlDecode(path); string filePath = HttpContext.Current.Server.MapPath(path); if (File.Exists(filePath)) { m_FileInfo = new FileInfo(filePath); } else if (HostingEnvironment.VirtualPathProvider.FileExists(path)) { m_VirtualFile = HostingEnvironment.VirtualPathProvider.GetFile(path); } }