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);
}
}
