private static S GetConfigHelper <S>(VirtualPath vpath) where S : ConfigurationSection
{
string physicalPath = null;
if ((vpath == null) || !vpath.IsWithinAppRoot)
{
vpath = HostingEnvironment.ApplicationVirtualPathObject;
physicalPath = HostingEnvironment.ApplicationPhysicalPath;
}
else
{
if (!vpath.DirectoryExists())
{
vpath = vpath.Parent;
}
physicalPath = HostingEnvironment.MapPath(vpath);
}
System.Configuration.Configuration configuration = GetConfiguration(vpath, physicalPath);
if (typeof(S) == typeof(CompilationSection))
{
return(configuration.GetSection("system.web/compilation") as S);
}
if (typeof(S) == typeof(PagesSection))
{
return(configuration.GetSection("system.web/pages") as S);
}
if (typeof(S) != typeof(ProfileSection))
{
throw new InvalidOperationException(System.Web.SR.GetString("Config_section_not_supported", new object[] { typeof(S).FullName }));
}
return(configuration.GetSection("system.web/profile") as S);
}
internal string GetGeneratedSourceFile(VirtualPath virtualPath)
{
// Add a pending call to make sure our thread doesn't get killed
AddPendingCall();
Type codeDomProviderType;
CompilerParameters compilerParameters;
string generatedFilesDir;
try {
if (!virtualPath.DirectoryExists())
{
throw new ArgumentException(SR.GetString(SR.GetGeneratedSourceFile_Directory_Only,
virtualPath.VirtualPathString), "virtualPath");
}
// Calls GetCodeDirectoryInformation to ensure the source files are created for the
// directory specified by virtualPath
GetCodeDirectoryInformation(virtualPath,
out codeDomProviderType, out compilerParameters,
out generatedFilesDir);
return(BuildManager.GenerateFileTable[virtualPath.VirtualPathStringNoTrailingSlash]);
}
finally {
RemovePendingCall();
}
}
private static bool VirtualDirectoryExistsWithAssert(VirtualPath virtualDir)
{
try
{
string path = virtualDir.MapPathInternal();
if (path != null)
{
new FileIOPermission(FileIOPermissionAccess.Read, path).Assert();
}
return(virtualDir.DirectoryExists());
}
catch
{
return(false);
}
}
// Actual method performing to work to retrieve the required ConfigurationSection.
static private S GetConfigHelper <S>(VirtualPath vpath) where S : ConfigurationSection
{
string physicalPath = null;
if (vpath == null || !vpath.IsWithinAppRoot)
{
// If virtual path is null or outside the application root, we use the application level config.
vpath = HostingEnvironment.ApplicationVirtualPathObject;
physicalPath = HostingEnvironment.ApplicationPhysicalPath;
}
else
{
// If it is not a directory, use the directory as the vpath
if (!vpath.DirectoryExists())
{
vpath = vpath.Parent;
}
physicalPath = HostingEnvironment.MapPath(vpath);
}
Configuration config = GetConfiguration(vpath, physicalPath);
// Retrieve the specified section
if (typeof(S) == typeof(CompilationSection))
{
return(config.GetSection("system.web/compilation") as S);
}
else if (typeof(S) == typeof(PagesSection))
{
return(config.GetSection("system.web/pages") as S);
}
else if (typeof(S) == typeof(ProfileSection))
{
return(config.GetSection("system.web/profile") as S);
}
throw new InvalidOperationException(SR.GetString(SR.Config_section_not_supported, typeof(S).FullName));
}
internal string GetGeneratedSourceFile(VirtualPath virtualPath)
{
string str2;
this.AddPendingCall();
try
{
Type type;
CompilerParameters parameters;
string str;
if (!virtualPath.DirectoryExists())
{
throw new ArgumentException(System.Web.SR.GetString("GetGeneratedSourceFile_Directory_Only", new object[] { virtualPath.VirtualPathString }), "virtualPath");
}
this.GetCodeDirectoryInformation(virtualPath, out type, out parameters, out str);
str2 = BuildManager.GenerateFileTable[virtualPath.VirtualPathStringNoTrailingSlash];
}
finally
{
this.RemovePendingCall();
}
return(str2);
}
private static bool VirtualDirectoryExistsWithAssert(VirtualPath virtualDir) {
try {
String physicalDir = virtualDir.MapPathInternal();
if (physicalDir != null) {
new FileIOPermission(FileIOPermissionAccess.Read, physicalDir).Assert();
}
return virtualDir.DirectoryExists();
}
catch {
return false;
}
}
internal static void ReportDirectoryCompilationProgress(VirtualPath virtualDir) {
// Nothing to do if there is no CBM callback
if (CBMCallback == null)
return;
// Don't report anything if the directory doesn't exist
if (!virtualDir.DirectoryExists())
return;
string message = SR.GetString(SR.Directory_progress, virtualDir.VirtualPathString);
CBMCallback.ReportProgress(message);
}
private static BuildResultCompiledType GetThemeBuildResultType(string themeName)
{
string appThemeCacheKey, globalThemeCacheKey = null;
// First, check if the application theme is cached
appThemeCacheKey = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
BuildResultCompiledType result = (BuildResultCompiledType)
BuildManager.GetBuildResultFromCache(appThemeCacheKey);
if (result == null)
{
// Then, check if the global theme is cached
globalThemeCacheKey = "GlobalTheme_" + themeName;
result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(
globalThemeCacheKey);
}
// If we found a theme buildresulttype, return it
if (result != null)
{
return(result);
}
bool gotLock = false;
try {
// Grab the compilation mutex
CompilationLock.GetLock(ref gotLock);
// Check the cache again now that we have the mutex
result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(appThemeCacheKey);
if (result == null)
{
result = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(
globalThemeCacheKey);
}
if (result != null)
{
return(result);
}
// Theme was not found in the caches; check if the directory exists.
VirtualPath appVirtualDir, globalVirtualDir = null;
appVirtualDir = GetAppThemeVirtualDir(themeName);
PageThemeBuildProvider themeBuildProvider = null;
VirtualPath virtualDir = appVirtualDir;
string cacheKey = appThemeCacheKey;
// If the theme directories do not exist, simply throw
if (appVirtualDir.DirectoryExists())
{
themeBuildProvider = new PageThemeBuildProvider(appVirtualDir);
}
else
{
globalVirtualDir = GetGlobalThemeVirtualDir(themeName);
if (!globalVirtualDir.DirectoryExists())
{
throw new HttpException(SR.GetString(SR.Page_theme_not_found, themeName));
}
virtualDir = globalVirtualDir;
cacheKey = globalThemeCacheKey;
themeBuildProvider = new GlobalPageThemeBuildProvider(globalVirtualDir);
}
// The directory exists (either app or global), so compile it
DateTime utcStart = DateTime.UtcNow;
VirtualDirectory vdir = virtualDir.GetDirectory();
// Add all the .skin files to it
AddThemeFilesToBuildProvider(vdir, themeBuildProvider, true);
// Use predictable fixed names for theme assemblies.
BuildProvidersCompiler bpc = new BuildProvidersCompiler(virtualDir,
themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));
// Add the single build provider to the BuildProvidersCompiler
bpc.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));
// Compile it
CompilerResults results = bpc.PerformBuild();
// Get the Type we care about from the BuildProvider
result = (BuildResultCompiledType)themeBuildProvider.GetBuildResult(results);
// Cache it for next time
BuildManager.CacheBuildResult(cacheKey, result, utcStart);
}
finally {
// Always release the mutex if we had taken it
if (gotLock)
{
CompilationLock.ReleaseLock();
}
}
return(result);
}
private static BuildResultCompiledType GetThemeBuildResultType(string themeName)
{
string cacheKey = null;
string str = "Theme_" + Util.MakeValidTypeNameFromString(themeName);
BuildResultCompiledType buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(str);
if (buildResultFromCache == null)
{
cacheKey = "GlobalTheme_" + themeName;
buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(cacheKey);
}
if (buildResultFromCache == null)
{
bool gotLock = false;
try
{
CompilationLock.GetLock(ref gotLock);
buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(str);
if (buildResultFromCache == null)
{
buildResultFromCache = (BuildResultCompiledType)BuildManager.GetBuildResultFromCache(cacheKey);
}
if (buildResultFromCache != null)
{
return(buildResultFromCache);
}
VirtualPath virtualDirPath = null;
VirtualPath appThemeVirtualDir = GetAppThemeVirtualDir(themeName);
PageThemeBuildProvider themeBuildProvider = null;
VirtualPath configPath = appThemeVirtualDir;
string str3 = str;
if (appThemeVirtualDir.DirectoryExists())
{
themeBuildProvider = new PageThemeBuildProvider(appThemeVirtualDir);
}
else
{
virtualDirPath = GetGlobalThemeVirtualDir(themeName);
if (!virtualDirPath.DirectoryExists())
{
throw new HttpException(System.Web.SR.GetString("Page_theme_not_found", new object[] { themeName }));
}
configPath = virtualDirPath;
str3 = cacheKey;
themeBuildProvider = new GlobalPageThemeBuildProvider(virtualDirPath);
}
DateTime utcNow = DateTime.UtcNow;
AddThemeFilesToBuildProvider(configPath.GetDirectory(), themeBuildProvider, true);
BuildProvidersCompiler compiler = new BuildProvidersCompiler(configPath, themeBuildProvider.AssemblyNamePrefix + BuildManager.GenerateRandomAssemblyName(themeName));
compiler.SetBuildProviders(new SingleObjectCollection(themeBuildProvider));
CompilerResults results = compiler.PerformBuild();
buildResultFromCache = (BuildResultCompiledType)themeBuildProvider.GetBuildResult(results);
BuildManager.CacheBuildResult(str3, buildResultFromCache, utcNow);
}
finally
{
if (gotLock)
{
CompilationLock.ReleaseLock();
}
}
}
return(buildResultFromCache);
}
