private VirtualDirectoryMapping(VirtualPath virtualDirectory, string physicalDirectory, bool isAppRoot, string configFileBaseName) {
_virtualDirectory = virtualDirectory;
_isAppRoot = isAppRoot;
PhysicalDirectory = physicalDirectory;
ConfigFileBaseName = configFileBaseName;
}
internal PageThemeBuildProvider(VirtualPath virtualDirPath) {
_virtualDirPath = virtualDirPath;
//
SetVirtualPath(virtualDirPath);
}
// Create a PageParserFilter and initialize it
internal static PageParserFilter Create(PagesSection pagesConfig, VirtualPath virtualPath, TemplateParser parser) {
PageParserFilter pageParserFilter = pagesConfig.CreateControlTypeFilter();
if (pageParserFilter != null)
pageParserFilter.InitializeInternal(virtualPath, parser);
return pageParserFilter;
}
public IView GetView(VirtualPath path)
{
if (path.Parts.Count == 0) return null;
var filename = "../" + path.Parts.Last();
var candidatePaths = new VirtualPath[] { path }
.Concat(
from ext in _registry.GetRegisteredExtensions()
select path.Append(filename + "." + ext)
);
var infos =
from c in candidatePaths
let info = _registry.GetViewInfo(path)
let resource = info.Location(info.RelativePath, _serviceLocator)
where resource != null && resource.IsFile
select new {
Path = c,
Resource = resource
};
var viewInfo = infos.FirstOrDefault();
if (viewInfo == null) return null;
var resourceResolver = new ViewResourceResolver(_registry, _serviceLocator, viewInfo.Resource);
var extension = viewInfo.Path.Parts.Last().Split('.').Last();
var viewEngine = _registry.GetViewEngine(extension);
return viewEngine.GetView(viewInfo.Path, resourceResolver);
}
internal BuildResult ReadBuildResultFromFile(VirtualPath virtualPath, string preservationFile, long hashCode, bool ensureIsUpToDate) {
// Ignore if the preservation file doesn't exist
if (!FileUtil.FileExists(preservationFile)) {
Debug.Trace("PreservationFileReader", "Can't find preservation file " + Path.GetFileName(preservationFile));
return null;
}
BuildResult result = null;
try {
result = ReadFileInternal(virtualPath, preservationFile, hashCode, ensureIsUpToDate);
}
catch (SecurityException) {
// We eat all exceptions, except for SecurityException's, because they
// are ususally a sign that something is not set up correctly, and we
// don't want to lose the stack (VSWhidbey 269566)
throw;
}
catch {
if (!_precompilationMode) {
// The preservation file can't be used, so get rid of it
Util.RemoveOrRenameFile(preservationFile);
}
}
return result;
}
protected override string MapPath (VirtualPath virtualPath)
{
// We need this hack to support out-of-application wsdl helpers
if (virtualPath.IsFake)
return virtualPath.PhysicalPath;
return base.MapPath (virtualPath);
}
// if appHost is null, we use the site name for the current application
string IServerConfig.MapPath(IApplicationHost appHost, VirtualPath path) {
string siteName = (appHost == null) ? _siteNameForCurrentApplication : appHost.GetSiteName();
string physicalPath = ProcessHostConfigUtils.MapPathActual(siteName, path);
if (FileUtil.IsSuspiciousPhysicalPath(physicalPath)) {
throw new InvalidOperationException(SR.GetString(SR.Cannot_map_path, path.VirtualPathString));
}
return physicalPath;
}
public NTFSDirectory(NTFSFileSystemProvider fileSystemProvider, string name, VirtualPath path)
{
this.fileSystemProvider = fileSystemProvider;
Name = name;
if (path.IsRoot)
Name = string.Empty;
Path = path;
}
public ResourceMapping(VirtualPath root, IResourceLocation location)
{
if (root.Type != VirtualPathType.AppRelative) {
throw new ArgumentException("The root path must be app-relative.");
}
Root = root;
Location = location;
}
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization,
string outputAssemblyName) {
_configPath = configPath;
_supportLocalization = supportLocalization;
_compConfig = MTConfigUtil.GetCompilationConfig(_configPath);
_referencedAssemblies = BuildManager.GetReferencedAssemblies(CompConfig);
_outputAssemblyName = outputAssemblyName;
}
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization,
string generatedFilesDir, int index) {
_configPath = configPath;
_supportLocalization = supportLocalization;
_compConfig = MTConfigUtil.GetCompilationConfig(_configPath);
_referencedAssemblies = BuildManager.GetReferencedAssemblies(CompConfig, index);
_generatedFilesDir = generatedFilesDir;
}
protected void AddDependency(VirtualPath virtualPath) {
virtualPath = ResolveVirtualPath(virtualPath);
Debug.Trace("Template", "Parsed dependency: " + _virtualPath + " depends on " + virtualPath);
if (_virtualPathDependencies == null)
_virtualPathDependencies = new CaseInsensitiveStringSet();
_virtualPathDependencies.Add(virtualPath.VirtualPathString);
}
protected override IView CreateView(VirtualPath pathToView, IResourceResolver resolver)
{
var resource = resolver.GetResource(pathToView);
if (resource == null || !resource.IsFile) {
return null;
}
return new NustacheView(this, pathToView, resource, resolver);
}
internal CodeBlockBuilder(CodeBlockType blockType, string content, int lineNumber, int column, VirtualPath virtualPath, bool encode) {
_content = content;
_blockType = blockType;
_column = column;
IsEncoded = encode;
Line = lineNumber;
VirtualPath = virtualPath;
}
public DotLiquidView(VirtualPath path, IResource resource, IResourceResolver resolver)
{
_path = path;
_resolver = resolver;
using (var stream = resource.Open())
using (var reader = new StreamReader(stream)) {
string tpl = reader.ReadToEnd();
_template = Template.Parse(tpl);
}
}
private Template GetChildTemplate(string path)
{
var newPath = new VirtualPath(path);
if (newPath.Type != VirtualPathType.AppRelative) {
throw new NotSupportedException("The Nustache view engine only supports app-relative paths at present.");
}
var result = _engine.GetView(newPath, _resolver) as NustacheView;
if (result == null) return null;
return result.Template;
}
IHttpHandler IHttpHandlerFactory2.GetHandler(HttpContext context, String requestType,
VirtualPath virtualPath, String physicalPath) {
// If it's a derived class, we must call the old (less efficient) GetHandler, in
// case it was overriden
if (_isInheritedInstance) {
return GetHandler(context, requestType, virtualPath.VirtualPathString, physicalPath);
}
return GetHandlerHelper(context, requestType, virtualPath, physicalPath);
}
protected override TextReader SpecialOpenReader (VirtualPath virtualPath, out string physicalPath)
{
// We need this hack to support out-of-application wsdl helpers
if (virtualPath.IsFake) {
physicalPath = virtualPath.PhysicalPath;
return new StreamReader (physicalPath);
} else
physicalPath = null;
return base.SpecialOpenReader (virtualPath, out physicalPath);
}
public IResource GetResource(VirtualPath path)
{
var resourceName = String.Join(".",
new[] { RootNamespace }.Concat(path.Parts)
);
var name = this.Assembly.GetManifestResourceNames().FirstOrDefault
(x => x.Equals(resourceName, StringComparison.OrdinalIgnoreCase));
if (name == null) return null;
return new AssemblyResource(this.Assembly, name);
}
public IResource GetResource(VirtualPath path)
{
if (_initialResource != null) {
var result = _initialResource;
_initialResource = null;
return result;
}
var info = _registry.GetViewInfo(path);
return info.Location(info.RelativePath, _serviceLocator);
}
public NustacheView(NustacheViewEngine engine, VirtualPath path, IResource resource, IResourceResolver resolver)
{
_engine = engine;
_path = path;
_resolver = resolver;
using (var stream = resource.Open())
using (var reader = new StreamReader(stream)) {
Template = new Template();
Template.Load(reader);
}
}
public IResource GetResource(VirtualPath path)
{
var parts = new string[] { Root }.Concat(path.Parts).ToArray();
var physicalPath = Path.Combine(parts);
if (File.Exists(physicalPath)) {
return new FileResource(physicalPath);
}
else {
return null;
}
}
IHttpHandler IHttpHandlerFactory2.GetHandler(HttpContext context, String requestType,
VirtualPath virtualPath, String physicalPath) {
BuildResultCompiledType result = (BuildResultCompiledType)BuildManager.GetVPathBuildResult(
context, virtualPath);
// Make sure the type has the correct base class (ASURT 123677)
Util.CheckAssignableType(typeof(IHttpHandler), result.ResultType);
return (IHttpHandler) result.CreateInstance();
}
private IHttpHandler GetHandlerHelper(HttpContext context, string requestType,
VirtualPath virtualPath, string physicalPath) {
Page page = BuildManager.CreateInstanceFromVirtualPath(
virtualPath, typeof(Page), context, true /*allowCrossApp*/) as Page;
if (page == null)
return null;
page.TemplateControlVirtualPath = virtualPath;
return page;
}
private void GetPathConfigFilenameWorker(string siteID, VirtualPath path, out string directory, out string baseName) {
directory = MapPathCaching(siteID, path);
if (directory != null) {
baseName = HttpConfigurationSystem.WebConfigFileName;
}
else {
baseName = null;
}
Debug.Trace("MapPath", "ProcHostMP.GetPathConfigFilename(" + siteID + ", " + path + ")\n" +
" result = " + directory + " and " + baseName + "\n");
}
public IResource GetResource(VirtualPath path)
{
var candidates =
from mapping in _mappings
let mine = mapping.Root.GetSubPath(path, true)
where mine != null
orderby mapping.Root.Parts.Count descending
let resource = mapping.GetResource(mine)
where resource != null
select resource;
return candidates.FirstOrDefault();
}
internal HttpHandlerAction FindMapping(String verb, VirtualPath path) {
ValidateHandlers();
for (int i = 0; i < Handlers.Count; i++) {
HttpHandlerAction m = (HttpHandlerAction)Handlers[i];
if (m.IsMatch(verb, path)) {
return m;
}
}
return null;
}
#pragma warning restore 0649
internal static BuildResult CreateBuildResultFromCode(BuildResultTypeCode code,
VirtualPath virtualPath) {
BuildResult ret = null;
switch (code) {
case BuildResultTypeCode.BuildResultCompiledAssembly:
ret = new BuildResultCompiledAssembly();
break;
case BuildResultTypeCode.BuildResultCompiledType:
ret = new BuildResultCompiledType();
break;
case BuildResultTypeCode.BuildResultCompiledTemplateType:
ret = new BuildResultCompiledTemplateType();
break;
case BuildResultTypeCode.BuildResultCompiledGlobalAsaxType:
ret = new BuildResultCompiledGlobalAsaxType();
break;
case BuildResultTypeCode.BuildResultCustomString:
ret = new BuildResultCustomString();
break;
case BuildResultTypeCode.BuildResultMainCodeAssembly:
ret = new BuildResultMainCodeAssembly();
break;
case BuildResultTypeCode.BuildResultResourceAssembly:
ret = new BuildResultResourceAssembly();
break;
case BuildResultTypeCode.BuildResultCodeCompileUnit:
ret = new BuildResultCodeCompileUnit();
break;
default:
Debug.Assert(false, "code=" + code);
return null;
}
ret.VirtualPath = virtualPath;
// Set _nextUpToDateCheck to MinValue, to make sure the next call to IsUpToDate()
// actually makes the check
ret._nextUpToDateCheck = DateTime.MinValue;
return ret;
}
public static Uri GetAbsoluteUrl(this IRequest request, VirtualPath path)
{
switch (path.Type)
{
case VirtualPathType.Absolute:
return new Uri(request.Url, "/" + path.Path);
case VirtualPathType.AppRelative:
return new Uri(request.Url, "/" + request.Path.Append(path).Path);
case VirtualPathType.RequestRelative:
return new Uri(request.Url, path.Path);
default:
throw new ArgumentException("The path has an invalid type.", "path");
}
}
public IView GetView(VirtualPath pathToView, IResourceResolver resolver)
{
if (_settings.Debug)
{
return CreateView(pathToView, resolver);
}
IView result = null;
string key = pathToView.Path;
if (!_cache.TryGetValue(key, out result)) {
result = CreateView(pathToView, resolver);
_cache[key] = result;
}
return result;
}
/*
* Compile a nested .ascx file (a User Control) and return its Type
*/
protected internal Type GetUserControlType(string virtualPath)
{
return(GetUserControlType(VirtualPath.Create(virtualPath)));
}
internal WebHandlerParser(HttpContext context, VirtualPath virtualPath, TextReader reader)
: this(context, virtualPath, null, reader)
{
}
internal Type GetReferencedType(VirtualPath virtualPath)
{
return(GetReferencedType(virtualPath, true /*allowNoCompile*/));
}
public DatePickerJsModuleIncludeDescriptor(RootModuleDescriptor module)
: base(module, "bcms.datepicker")
{
Links = new IActionProjection[]
{
new JavaScriptModuleLink(this, "calendarImageUrl", VirtualPath.Combine(module.CssBasePath, "images", "icn-calendar.png"))
};
Globalization = new IActionProjection[]
{
new JavaScriptModuleGlobalization(this, "dateFormat", () =>
{
// C# date format map to jQuery date picked.
// References:
// * http://msdn.microsoft.com/en-us/library/8kb3ddd4(v=vs.110).aspx
// * http://www.phpeveryday.com/articles/jQuery-UI-Changing-the-date-format-for-Datepicker-P1023.html
var datePattern = Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern;
// Year:
if (datePattern.Contains("yyyy"))
{
// year (four digits).
datePattern = datePattern.Replace("yyyy", "yy");
}
else if (datePattern.Contains("yy"))
{
// year (two digits).
datePattern = datePattern.Replace("yy", "y");
}
// Month:
if (datePattern.Contains("MMMM"))
{
// long month name.
datePattern = datePattern.Replace("MMMM", "MM");
}
else if (datePattern.Contains("MMM"))
{
// short month name.
datePattern = datePattern.Replace("MMM", "M");
}
else if (datePattern.Contains("MM"))
{
// month of year (two digits).
datePattern = datePattern.Replace("MM", "mm");
}
else if (datePattern.Contains("M"))
{
// month of year (single digit where applicable).
datePattern = datePattern.Replace("M", "m");
}
// Day:
if (datePattern.Contains("dddd"))
{
// full day name.
datePattern = datePattern.Replace("dddd", "DD");
}
else if (datePattern.Contains("ddd"))
{
// short day name.
datePattern = datePattern.Replace("ddd", "D");
}
return(datePattern);
}),
new JavaScriptModuleGlobalization(this, "currentCulture", () => Thread.CurrentThread.CurrentCulture.Name),
};
}
internal WebHandlerParser(HttpContext context, VirtualPath virtualPath, string physicalPath, TextReader reader)
: base(context, virtualPath.Original, physicalPath, reader)
{
}
public ExpressionBuilderContext(string virtualPath)
{
_virtualPath = System.Web.VirtualPath.Create(virtualPath);
}
protected VirtualFile(string virtualPath)
{
base._virtualPath = VirtualPath.Create(virtualPath);
}
internal override void ProcessDirective(string directiveName, IDictionary directive)
{
if (StringUtil.EqualsIgnoreCase(directiveName, "register"))
{
// Register directive
// Get the tagprefix, which is required
string tagPrefix = Util.GetAndRemoveNonEmptyIdentifierAttribute(directive,
"tagprefix", true /*required*/);
string tagName = Util.GetAndRemoveNonEmptyIdentifierAttribute(directive,
_tagnameString, false /*required*/);
VirtualPath src = Util.GetAndRemoveVirtualPathAttribute(directive,
_sourceString, false /*required*/);
string ns = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive,
_namespaceString, false /*required*/);
// An Assembly can optionally be specified (ASURT 61326/VSWhidbey 87050)
string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "assembly",
false /*required*/);
RegisterDirectiveEntry registerEntry;
if (tagName != null)
{
// It's a user control registration
// 'src' is required
if (src == null)
{
throw new HttpException(SR.GetString(SR.Missing_attr, _sourceString));
}
// 'namespace' is not allowed
if (ns != null)
{
throw new HttpException(
SR.GetString(SR.Invalid_attr, _namespaceString, "tagname"));
}
// 'assembly' is not allowed
if (assemblyName != null)
{
throw new HttpException(
SR.GetString(SR.Invalid_attr, "assembly", "tagname"));
}
UserControlRegisterEntry ucRegisterEntry = new UserControlRegisterEntry(tagPrefix, tagName);
ucRegisterEntry.UserControlSource = src;
registerEntry = ucRegisterEntry;
TypeMapper.ProcessUserControlRegistration(ucRegisterEntry);
}
else if (src != null)
{
// It's missing the tagname attribute.
throw new HttpException(SR.GetString(SR.Missing_attr, _tagnameString));
}
else
{
// It's a namespace prefix registration
// 'namespace' is required
if (ns == null)
{
throw new HttpException(SR.GetString(SR.Missing_attr, _namespaceString));
}
TagNamespaceRegisterEntry nsRegisterEntry = new TagNamespaceRegisterEntry(tagPrefix, ns, assemblyName);
registerEntry = nsRegisterEntry;
TypeMapper.ProcessTagNamespaceRegistration(nsRegisterEntry);
}
registerEntry.Line = _lineNumber;
registerEntry.VirtualPath = CurrentVirtualPathString;
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
else
{
base.ProcessDirective(directiveName, directive);
}
}
/*
* Compile a .aspx/.ascx file and return its Type
*/
protected Type GetReferencedType(string virtualPath)
{
return(GetReferencedType(VirtualPath.Create(virtualPath)));
}
public string MapPath(string siteID, string path)
{
return(MapPath(siteID, VirtualPath.Create(path)));
}
internal static bool IsUserAllowedToPath(HttpContext context, VirtualPath virtualPath)
{
return(IsUserAllowedToFile(context, virtualPath.MapPath()));
}
public static bool CheckFileAccessForUser(String virtualPath, IntPtr token, string verb)
{
if (virtualPath == null)
{
throw new ArgumentNullException("virtualPath");
}
if (token == IntPtr.Zero)
{
throw new ArgumentNullException("token");
}
if (verb == null)
{
throw new ArgumentNullException("verb");
}
VirtualPath vPath = VirtualPath.Create(virtualPath);
if (!vPath.IsWithinAppRoot)
{
throw new ArgumentException(SR.GetString(SR.Virtual_path_outside_application_not_supported), "virtualPath");
}
if (!s_EnabledDetermined)
{
if (HttpRuntime.UseIntegratedPipeline)
{
s_Enabled = true; // always enabled in Integrated Mode
}
else
{
HttpModulesSection modulesSection = RuntimeConfig.GetConfig().HttpModules;
int len = modulesSection.Modules.Count;
for (int iter = 0; iter < len; iter++)
{
HttpModuleAction module = modulesSection.Modules[iter];
if (Type.GetType(module.Type, false) == typeof(FileAuthorizationModule))
{
s_Enabled = true;
break;
}
}
}
s_EnabledDetermined = true;
}
if (!s_Enabled)
{
return(true);
}
////////////////////////////////////////////////////////////
// Step 3: Check the cache for the file-security-descriptor
// for the requested file
bool freeDescriptor;
FileSecurityDescriptorWrapper oSecDesc = GetFileSecurityDescriptorWrapper(vPath.MapPath(), out freeDescriptor);
////////////////////////////////////////////////////////////
// Step 4: Check if access is allowed
int iAccess = 3;
if (verb == "GET" || verb == "POST" || verb == "HEAD" || verb == "OPTIONS")
{
iAccess = 1;
}
bool fAllowed = oSecDesc.IsAccessAllowed(token, iAccess);
////////////////////////////////////////////////////////////
// Step 5: Free the security descriptor if adding to cache failed
if (freeDescriptor)
{
oSecDesc.FreeSecurityDescriptor();
}
return(fAllowed);
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
string str2;
if (!s_triedToGetWebRefType)
{
s_indigoWebRefProviderType = BuildManager.GetType("System.Web.Compilation.WCFBuildProvider", false);
s_triedToGetWebRefType = true;
}
if (s_indigoWebRefProviderType != null)
{
BuildProvider provider = (BuildProvider)HttpRuntime.CreateNonPublicInstance(s_indigoWebRefProviderType);
provider.SetVirtualPath(base.VirtualPathObject);
provider.GenerateCode(assemblyBuilder);
}
VirtualPath webRefDirectoryVirtualPath = HttpRuntime.WebRefDirectoryVirtualPath;
string virtualPath = this._vdir.VirtualPath;
if (webRefDirectoryVirtualPath.VirtualPathString.Length == virtualPath.Length)
{
str2 = string.Empty;
}
else
{
string[] strArray = UrlPath.RemoveSlashFromPathIfNeeded(virtualPath).Substring(webRefDirectoryVirtualPath.VirtualPathString.Length).Split(new char[] { '/' });
for (int i = 0; i < strArray.Length; i++)
{
strArray[i] = Util.MakeValidTypeNameFromString(strArray[i]);
}
str2 = string.Join(".", strArray);
}
CodeNamespace proxyCode = new CodeNamespace(str2);
WebReferenceCollection webReferences = new WebReferenceCollection();
bool flag = false;
foreach (VirtualFile file in this._vdir.Files)
{
if (UrlPath.GetExtension(file.VirtualPath).ToLower(CultureInfo.InvariantCulture) == ".discomap")
{
string topLevelFilename = HostingEnvironment.MapPath(file.VirtualPath);
DiscoveryClientProtocol protocol = new DiscoveryClientProtocol {
AllowAutoRedirect = true,
Credentials = CredentialCache.DefaultCredentials
};
protocol.ReadAll(topLevelFilename);
WebReference reference = new WebReference(protocol.Documents, proxyCode);
string str5 = Path.ChangeExtension(UrlPath.GetFileName(file.VirtualPath), null);
string appSettingUrlKey = str2 + "." + str5;
WebReference webReference = new WebReference(protocol.Documents, proxyCode, reference.ProtocolName, appSettingUrlKey, null);
webReferences.Add(webReference);
flag = true;
}
}
if (flag)
{
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(proxyCode);
WebReferenceOptions options = new WebReferenceOptions {
CodeGenerationOptions = CodeGenerationOptions.GenerateOldAsync | CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateProperties,
Style = ServiceDescriptionImportStyle.Client,
Verbose = true
};
ServiceDescriptionImporter.GenerateWebReferences(webReferences, assemblyBuilder.CodeDomProvider, codeCompileUnit, options);
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
}
}
internal GlobalPageThemeBuildProvider(VirtualPath virtualDirPath) : base(virtualDirPath)
{
this._virtualDirPath = virtualDirPath;
}
internal BuildProvidersCompiler(VirtualPath configPath, string outputAssemblyName) :
this(configPath, false, outputAssemblyName)
{
}
public void GetPathConfigFilename(
string siteID, string path, out string directory, out string baseName)
{
GetPathConfigFilename(siteID, VirtualPath.Create(path), out directory, out baseName);
}
public StaticResult(VirtualPath path)
{
this.Path = path;
}
internal ExpressionBuilderContext(VirtualPath virtualPath)
{
_virtualPath = virtualPath;
}
internal Type GetReferencedType(VirtualPath virtualPath, bool allowNoCompile)
{
virtualPath = ResolveVirtualPath(virtualPath);
// If we have a page parser filter, make sure the reference is allowed
if (_pageParserFilter != null && !_pageParserFilter.AllowVirtualReference(CompConfig, virtualPath))
{
ProcessError(SR.GetString(SR.Reference_not_allowed, virtualPath));
}
BuildResult result = null;
Type t = null;
try {
result = BuildManager.GetVPathBuildResult(virtualPath);
}
catch (HttpCompileException e) {
// Add the path depdencies properly so we know when
// to invalidate the cached result.
if (e.VirtualPathDependencies != null)
{
foreach (string vPath in e.VirtualPathDependencies)
{
AddSourceDependency(VirtualPath.Create(vPath));
}
}
throw;
}
catch {
// Add the virtualPath to the dependency so that
// we know when to check again. This could happen if the
// virtualPath points to a file not created yet.
// This only affects designtime code path since we do want to return
// partial result even if there is an error, and that result is
// cached. VSWhidbey 372585
if (IgnoreParseErrors)
{
AddSourceDependency(virtualPath);
}
throw;
}
// Is it a no-compile page/uc
BuildResultNoCompileTemplateControl noCompileResult = result as BuildResultNoCompileTemplateControl;
if (noCompileResult != null)
{
// If no-compile is not acceptable, return null
if (!allowNoCompile)
{
return(null);
}
// In the no-compile case, use the base type, since we don't compile a type
t = noCompileResult.BaseType;
}
else if (result is BuildResultCompiledType)
{
BuildResultCompiledType compiledResult = (BuildResultCompiledType)result;
Debug.Assert(compiledResult != null);
t = compiledResult.ResultType;
}
else
{
throw new HttpException(SR.GetString(SR.Invalid_typeless_reference, _sourceString));
}
Debug.Assert(t != null);
// Add a dependency on the Type
AddTypeDependency(t);
// Add a dependency on the BuildResult
AddBuildResultDependency(result);
return(t);
}
