public static ExpressionEditor GetExpressionEditor(string expressionPrefix, IServiceProvider serviceProvider)
{
if (serviceProvider == null)
{
return(null);
}
IWebApplication webApp = (IWebApplication)serviceProvider.GetService(typeof(IWebApplication));
if (webApp == null)
{
return(null);
}
_Configuration config = webApp.OpenWebConfiguration(true);
if (config == null)
{
return(null);
}
CompilationSection sec = (CompilationSection)config.GetSection("system.web/compilation");
System.Web.Configuration.ExpressionBuilder builder = sec.ExpressionBuilders [expressionPrefix];
if (builder == null)
{
return(null);
}
return(GetExpressionEditor(Type.GetType(builder.Type), serviceProvider));
}
protected void Page_Init(object sender, EventArgs e)
{
config = WebConfigurationManager.OpenWebConfiguration("/mod9lab");
compilation =
(CompilationSection)config.GetSection("system.web/compilation");
_debugStatus = compilation.Debug;
}
internal static Type GetBuildProviderTypeFromExtension(CompilationSection config, string extension, BuildProviderAppliesTo neededFor, bool failIfUnknown)
{
BuildProviderInfo buildProviderInfo = System.Web.Compilation.BuildProvider.GetBuildProviderInfo(config, extension);
Type c = null;
if (((buildProviderInfo != null) && (buildProviderInfo.Type != typeof(IgnoreFileBuildProvider))) && (buildProviderInfo.Type != typeof(ForceCopyBuildProvider)))
{
c = buildProviderInfo.Type;
}
if (((neededFor == BuildProviderAppliesTo.Web) && BuildManager.PrecompilingForUpdatableDeployment) && !typeof(BaseTemplateBuildProvider).IsAssignableFrom(c))
{
c = null;
}
if (c != null)
{
if ((neededFor & buildProviderInfo.AppliesTo) != 0)
{
return(c);
}
}
else if ((neededFor != BuildProviderAppliesTo.Resources) && (config.GetCompilerInfoFromExtension(extension, false) != null))
{
return(typeof(SourceFileBuildProvider));
}
if (failIfUnknown)
{
throw new HttpException(System.Web.SR.GetString("Unknown_buildprovider_extension", new object[] { extension, neededFor.ToString() }));
}
return(null);
}
internal WebDirectoryBatchCompiler(VirtualDirectory vdir)
{
this._vdir = vdir;
this._utcStart = DateTime.UtcNow;
this._compConfig = MTConfigUtil.GetCompilationConfig(this._vdir.VirtualPath);
this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this._compConfig);
}
internal bool AllowVirtualReference(CompilationSection compConfig, System.Web.VirtualPath referenceVirtualPath)
{
VirtualReferenceType page;
string extension = referenceVirtualPath.Extension;
Type type = CompilationUtil.GetBuildProviderTypeFromExtension(compConfig, extension, BuildProviderAppliesTo.Web, false);
if (type == null)
{
return(false);
}
if (type == typeof(PageBuildProvider))
{
page = VirtualReferenceType.Page;
}
else if (type == typeof(UserControlBuildProvider))
{
page = VirtualReferenceType.UserControl;
}
else if (type == typeof(MasterPageBuildProvider))
{
page = VirtualReferenceType.Master;
}
else if (type == typeof(SourceFileBuildProvider))
{
page = VirtualReferenceType.SourceFile;
}
else
{
page = VirtualReferenceType.Other;
}
return(this.AllowVirtualReference(referenceVirtualPath.VirtualPathString, page));
}
// Add the referenced assemblies into the compileParameters. Notice that buildProviders do not have
// the correct referenced assemblies and we don't cache them since the assemblies could change
// between appdomains. (removing assemblies from bin, etc)
private void FixupReferencedAssemblies(VirtualPath virtualPath, CompilerParameters compilerParameters)
{
CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
ICollection referencedAssemblies = BuildManager.GetReferencedAssemblies(compConfig);
Util.AddAssembliesToStringCollection(referencedAssemblies, compilerParameters.ReferencedAssemblies);
}
protected override void ComputeHashCode(HashCodeCombiner hashCodeCombiner)
{
base.ComputeHashCode(hashCodeCombiner);
CompilationSection compilationConfig = MTConfigUtil.GetCompilationConfig(base.VirtualPath);
hashCodeCombiner.AddObject(compilationConfig.RecompilationHash);
}
static Settings()
{
//PagesSection ps = (PagesSection)WebConfigurationManager.GetSection("system.web/pages");
//List<string> ns = new List<string>(ps.Namespaces.Count);
//foreach (NamespaceInfo n in ps.Namespaces)
// ns.Add(n.Namespace);
CompilationSection cs = (CompilationSection)WebConfigurationManager.GetSection("system.web/compilation");
GlobalizationSection gs = (GlobalizationSection)WebConfigurationManager.GetSection("system.web/globalization");
SiteSection ss = SiteSection.GetSection();
_configSettings = new Settings();
_configSettings._rootUrl = HttpContext.Current.Request.ApplicationPath;
if (!_configSettings._rootUrl.EndsWith("/"))
{
_configSettings._rootUrl = string.Concat(_configSettings._rootUrl, "/");
}
//_configSettings._controllerNamespaces = ns.ToArray();
_configSettings._theme = ss.Theme;
_configSettings._themePath = GetTempPath(_configSettings._theme);
_configSettings._themeUrl = string.Concat(_configSettings._rootUrl, "themes/", _configSettings._theme, "/");
_configSettings._debug = cs.Debug;
_configSettings._responseEncoding = gs.ResponseEncoding;
_configSettings._fileEncoding = gs.FileEncoding;
_configSettings._urlMode = ss.UrlMode;
//_configSettings._urlExt = ss.UrlExt;
_configSettings._management = ss.Management;
_configSettings._wapDomain = ss.WapDomain;
_configSettings._subDomain = ss.SubDomain;
_configSettings._dataProvider = ss.DataProvider;
_configSettings._cacheMode = ss.CacheMode;
_configSettings._cacheProvider = ss.CacheProvider;
_configSettings._resources = ss.ResourcesUrl;
_configSettings._passport = ss.PassportUrl;
_configSettings._wapPassport = ss.WapPassportUrl;
}
public static void Configure()
{
JsEngineSwitcher.Instance.DefaultEngineName = V8JsEngine.EngineName;
CompilationSection compilationSection =
(CompilationSection)ConfigurationManager.GetSection("system.web/compilation");
if (compilationSection.Debug)
{
ReactSiteConfiguration.Configuration
.SetLoadBabel(false)
.SetLoadReact(false)
.SetReuseJavaScriptEngines(false)
//.DisableServerSideRendering()
.SetUseDebugReact(true)
.AddScriptWithoutTransform("~/scripts/server.js");
}
else
{
ReactSiteConfiguration.Configuration
.SetLoadBabel(false)
.SetLoadReact(false)
.AddScriptWithoutTransform("~/scripts/server.min.js");
}
}
private static bool GetDebugFromConfig()
{
CompilationSection section =
(CompilationSection)WebConfigurationManager.GetWebApplicationSection("system.web/compilation");
return(section.Debug);
}
internal AssemblyBuilder(CompilationSection compConfig, ICollection referencedAssemblies, CompilerType compilerType, string outputAssemblyName)
{
this._compConfig = compConfig;
this._outputAssemblyName = outputAssemblyName;
this._initialReferencedAssemblies = AssemblySet.Create(referencedAssemblies);
this._compilerType = compilerType.Clone();
if (BuildManager.PrecompilingWithDebugInfo)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = true;
}
else if (BuildManager.PrecompilingForDeployment)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (DeploymentSection.RetailInternal)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = false;
}
else if (this._compConfig.AssemblyPostProcessorTypeInternal != null)
{
this._compilerType.CompilerParameters.IncludeDebugInformation = true;
}
this._tempFiles.KeepFiles = this._compilerType.CompilerParameters.IncludeDebugInformation;
this._codeProvider = CompilationUtil.CreateCodeDomProviderNonPublic(this._compilerType.CodeDomProviderType);
this._maxBatchSize = this._compConfig.MaxBatchSize;
this._maxBatchGeneratedFileSize = this._compConfig.MaxBatchGeneratedFileSize * 0x400;
}
private void LoadExpressionEditors()
{
this._expressionEditors = new HybridDictionary(true);
IWebApplication service = (IWebApplication)base.ServiceProvider.GetService(typeof(IWebApplication));
if (service != null)
{
try
{
System.Configuration.Configuration configuration = service.OpenWebConfiguration(true);
if (configuration != null)
{
CompilationSection section = (CompilationSection)configuration.GetSection("system.web/compilation");
foreach (ExpressionBuilder builder in section.ExpressionBuilders)
{
string expressionPrefix = builder.ExpressionPrefix;
ExpressionEditor expressionEditor = ExpressionEditor.GetExpressionEditor(expressionPrefix, base.ServiceProvider);
if (expressionEditor != null)
{
this._expressionEditors[expressionPrefix] = expressionEditor;
this._expressionBuilderComboBox.Items.Add(new ExpressionItem(expressionPrefix));
}
}
}
}
catch
{
}
this._expressionBuilderComboBox.InvalidateDropDownWidth();
}
this._expressionBuilderComboBox.Items.Add(this.NoneItem);
}
protected void Button1_Click(object sender, EventArgs e)
{
byte[] arr = new byte[24];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(arr);
System.Text.StringBuilder machineKey = new System.Text.StringBuilder(24);
for (int i = 0; i < arr.Length; i++)
{
machineKey.Append(String.Format("{0:X2}", arr[i]));
}
Page.Response.Write(machineKey.ToString());
Page.Response.Write(WebConfigurationManager.AppSettings["topic"] + "<br />");
Page.Response.Write(WebConfigurationManager.ConnectionStrings["NorthwindConnection"] + "<br />");
Page.Response.Write(WebConfigurationManager.GetSection("connectionStrings") + "<br />");
CompilationSection cs = (CompilationSection)WebConfigurationManager.GetSection("system.web/compilation");
foreach (AssemblyInfo item in cs.Assemblies)
{
Response.Write(item.Assembly + "<br /");
}
}
public static HtmlString ScriptLinkBundle(this HtmlHelper htmlHelper, IList <string> unbundledfiles, string bundledfile, string cachebusterKey = "")
{
string scripttags = string.Empty;
CompilationSection configSection = (CompilationSection)ConfigurationManager.GetSection("system.web/compilation");
if (configSection.Debug)
{
foreach (var file in unbundledfiles)
{
var scripttag = new TagBuilder("script");
scripttag.MergeAttribute("type", "text/javascript");
scripttag.MergeAttribute("src", file);
scripttags += scripttag.ToString();
}
}
else
{
var scripttag = new TagBuilder("script");
scripttag.MergeAttribute("type", "text/javascript");
if (string.IsNullOrWhiteSpace(cachebusterKey) || ConfigurationManager.AppSettings[cachebusterKey] == null)
{
scripttag.MergeAttribute("src", bundledfile);
}
else
{
scripttag.MergeAttribute("src", string.Format("{0}?v={1}", bundledfile, ConfigurationManager.AppSettings[cachebusterKey]));
}
scripttags = scripttag.ToString();
}
return(new HtmlString(scripttags));
}
internal static CodeDomProvider CreateProvider(HttpContext context, string lang, out CompilerParameters par, out string tempdir)
{
CodeDomProvider ret = null;
par = null;
CompilationSection config = (CompilationSection)WebConfigurationManager.GetWebApplicationSection("system.web/compilation");
Compiler comp = config.Compilers[lang];
if (comp == null)
{
CompilerInfo info = CodeDomProvider.GetCompilerInfo(lang);
if (info != null && info.IsCodeDomProviderTypeValid)
{
ret = info.CreateProvider();
par = info.CreateDefaultCompilerParameters();
}
}
else
{
Type t = HttpApplication.LoadType(comp.Type, true);
ret = Activator.CreateInstance(t) as CodeDomProvider;
par = new CompilerParameters();
par.CompilerOptions = comp.CompilerOptions;
par.WarningLevel = comp.WarningLevel;
}
tempdir = config.TempDirectory;
return(ret);
}
public void Defaults()
{
CompilationSection c = new CompilationSection();
Assert.IsNotNull(c.Assemblies, "A1");
Assert.AreEqual("", c.AssemblyPostProcessorType, "A2");
Assert.IsTrue(c.Batch, "A3");
Assert.AreEqual(TimeSpan.FromMinutes(15), c.BatchTimeout, "A4");
Assert.IsNotNull(c.BuildProviders, "A5");
Assert.IsNotNull(c.CodeSubDirectories, "A6");
Assert.IsNotNull(c.Compilers, "A7");
Assert.IsFalse(c.Debug, "A8");
Assert.AreEqual("vb", c.DefaultLanguage, "A9");
Assert.IsTrue(c.Explicit, "A10");
Assert.IsNotNull(c.ExpressionBuilders, "A11");
Assert.AreEqual(1000, c.MaxBatchSize, "A12");
Assert.AreEqual(15, c.NumRecompilesBeforeAppRestart, "A13");
Assert.IsFalse(c.Strict, "A14");
Assert.AreEqual("", c.TempDirectory, "A15");
Assert.IsFalse(c.UrlLinePragmas, "A16");
}
// Returns the list of buildProvider types associated to the specified appliesTo
internal static List <Type> GetFolderLevelBuildProviderTypes(CompilationSection config,
FolderLevelBuildProviderAppliesTo appliesTo)
{
FolderLevelBuildProviderCollection buildProviders = config.FolderLevelBuildProviders;
return(buildProviders.GetBuildProviderTypes(appliesTo));
}
private bool CheckAuth(HttpContext context)
{
CompilationSection ds = (CompilationSection)WebConfigurationManager.GetSection("system.web/compilation");
if (ds.Debug)
{
return(true);
}
bool result = false;
string access_token = context.Request["access_token"];
List <ApiToken> tokenList = context.Application["api_token"] as List <ApiToken>;
if (tokenList == null)
{
tokenList = new List <ApiToken>();
}
ApiToken token = (from i in tokenList where i.access_token == access_token select i).SingleOrDefault();
if (token != null)
{
if (token.update_time.AddSeconds(7200) <= DateTime.Now)
{
result = true;
}
}
return(result);
}
void ProcessRemove(string val, CompilationSection section, SettingsMappingWhatContents how)
{
if (val == "assemblies")
{
RemoveAssembly(section, how);
}
}
/*
* Return a CompilerType that a language maps to.
*/
internal static CompilerType GetCompilerInfoFromLanguage(VirtualPath configPath, string language)
{
// Get the <compilation> config object
CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath);
return(config.GetCompilerInfoFromLanguage(language));
}
/*
* Return a CompilerType that a extension maps to.
*/
private static CompilerType GetCompilerInfoFromExtension(VirtualPath configPath, string extension)
{
// Get the <compilation> config object
CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath);
return(config.GetCompilerInfoFromExtension(extension, true /*throwOnFail*/));
}
/// <inheritdoc/>
protected override void OnException(ExceptionContext filterContext)
{
CompilationSection compilationSection = (CompilationSection)WebConfigurationManager.GetSection(@"system.web/compilation");
if (compilationSection.Debug)
{
return;
}
if (filterContext.ExceptionHandled)
{
return;
}
// Log the exception.
LogHelper.Error <ZoombracoController>("Handled Exception: ", filterContext.Exception);
// Set the correct view.
HttpException httpException = filterContext.Exception as HttpException;
if (httpException != null)
{
int statusCode = httpException.GetHttpCode();
filterContext.HttpContext.Response.StatusDescription = httpException.Message;
filterContext.HttpContext.Response.StatusCode = statusCode;
}
filterContext.Result = this.View(this.ErrorViewName);
filterContext.ExceptionHandled = true;
}
/*
* Returns an array of the assemblies defined in the bin and assembly reference config section
*/
internal String[] GetTopLevelAssemblyReferences(VirtualPath virtualPath)
{
// Add a pending call to make sure our thread doesn't get killed
AddPendingCall();
List <Assembly> assemblyList = new List <Assembly>();
try {
// Treat it as relative to the app root
virtualPath.CombineWithAppRoot();
CompilationSection compConfig = MTConfigUtil.GetCompilationConfig(virtualPath);
// Add all the config assemblies to the list
foreach (AssemblyInfo assemblyInfo in compConfig.Assemblies)
{
Assembly[] assemblies = assemblyInfo.AssemblyInternal;
for (int i = 0; i < assemblies.Length; i++)
{
if (assemblies[i] != null)
{
assemblyList.Add(assemblies[i]);
}
}
}
} finally {
RemovePendingCall();
}
StringCollection paths = new StringCollection();
Util.AddAssembliesToStringCollection(assemblyList, paths);
string[] references = new string[paths.Count];
paths.CopyTo(references, 0);
return(references);
}
/// <summary>
/// Check whether an assembly has dependencies to a framework assembly of a higher version,
/// report the issue as a warning or error.
/// </summary>
private static void CheckOutOfRangeDependencies(string assemblyName)
{
string dependencies = null;
Assembly assembly = Assembly.Load(assemblyName);
AssemblyName aName = new AssemblyName(assemblyName);
// If the loaded assembly has a different version than the specified assembly,
// then it is likely that there was unification or binding redirect in place.
// If that is the case, then GetReferenceAssemblies won't be accurate for
// finding the references of the actual assembly, so we skip checking its references.
if (assembly.GetName().Version != aName.Version)
{
return;
}
foreach (AssemblyName name in assembly.GetReferencedAssemblies())
{
try {
Assembly referenceAssembly = CompilationSection.LoadAndRecordAssembly(name);
string path;
ReferenceAssemblyType referenceAssemblyType =
GetPathToReferenceAssembly(referenceAssembly, out path, null, null, false /*checkDependencies*/);
// We need to check the following 2 conditions:
// 1. If the assembly is available in the target framework, we also need to
// verify that the version being referenced is no higher than what we have
// in the target framework.
// 2. If the assembly is only available in a higher version framework.
Version resolvedAssemblyVersion = GetAssemblyVersion(path);
if (resolvedAssemblyVersion == null)
{
continue;
}
if ((referenceAssemblyType == ReferenceAssemblyType.FrameworkAssembly && resolvedAssemblyVersion < name.Version) ||
referenceAssemblyType == ReferenceAssemblyType.FrameworkAssemblyOnlyPresentInHigherVersion)
{
if (dependencies == null)
{
dependencies = name.FullName;
}
else
{
dependencies += "; " + name.FullName;
}
}
}
catch {
// Ignore dependencies that are not found, as we are primarily concerned
// with framework assemblies that are on the machine.
}
}
if (dependencies != null)
{
string message = SR.GetString(SR.Higher_dependencies, assemblyName, dependencies);
ReportWarningOrError(message);
}
}
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, string outputAssemblyName)
{
this._configPath = configPath;
this._supportLocalization = supportLocalization;
this._compConfig = MTConfigUtil.GetCompilationConfig(this._configPath);
this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this.CompConfig);
this._outputAssemblyName = outputAssemblyName;
}
/*
* Return a file provider Type that an extension maps to.
*/
internal static Type GetBuildProviderTypeFromExtension(VirtualPath configPath, string extension,
BuildProviderAppliesTo neededFor, bool failIfUnknown)
{
// Get the <compilation> config object
CompilationSection config = MTConfigUtil.GetCompilationConfig(configPath);
return(GetBuildProviderTypeFromExtension(config, extension, neededFor, failIfUnknown));
}
internal AssemblyBuilder CreateAssemblyBuilder(CompilationSection compConfig, ICollection referencedAssemblies, string generatedFilesDir, string outputAssemblyName)
{
if (generatedFilesDir != null)
{
return(new CbmCodeGeneratorBuildProviderHost(compConfig, referencedAssemblies, this, generatedFilesDir, outputAssemblyName));
}
return(new AssemblyBuilder(compConfig, referencedAssemblies, this, outputAssemblyName));
}
internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, string generatedFilesDir, int index)
{
this._configPath = configPath;
this._supportLocalization = supportLocalization;
this._compConfig = MTConfigUtil.GetCompilationConfig(this._configPath);
this._referencedAssemblies = BuildManager.GetReferencedAssemblies(this.CompConfig, index);
this._generatedFilesDir = generatedFilesDir;
}
internal static AssemblyBuilder GetDefaultAssemblyBuilder(CompilationSection compConfig,
ICollection referencedAssemblies, VirtualPath configPath,
string generatedFilesDir, string outputAssemblyName)
{
CompilerType ctwp = GetDefaultCompilerTypeWithParams(compConfig, configPath);
return(ctwp.CreateAssemblyBuilder(compConfig, referencedAssemblies,
generatedFilesDir, outputAssemblyName));
}
public static BundleOptions GetBundleOptionByDebugMode()
{
CompilationSection compilationSection =
(CompilationSection)ConfigurationManager.GetSection(@"system.web/compilation");
return(compilationSection.Debug
? BundleOptions.Combined
: BundleOptions.MinifiedAndCombined);
}
