Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

943 lines
42 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="CompilationSection.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Configuration {
using System;
using System.Xml;
using System.Configuration;
using System.Collections.Concurrent;
using System.Collections.Specialized;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Text;
using System.Web.Compilation;
using System.Reflection;
using System.Web.Hosting;
using System.Web.UI;
using System.CodeDom.Compiler;
using System.Web.Util;
using System.Threading;
using System.ComponentModel;
using System.Security.Permissions;
/*
<!-- compilation Attributes:
tempDirectory="directory"
debug="[true|false]" // Default: false
strict="[true|false]" // Default: false
explicit="[true|false]" // Default: true !!! This follow how it was defined in Machine.config
batch="[true|false]" // Default: true
batchTimeout="timeout in seconds" // Default: 15 seconds
maxBatchSize="max number of pages per batched compilation" // Default: 1000 classes
maxBatchGeneratedFileSize="max combined size (in KB) of the generated source files per batched compilation" // Default: 3000KB
numRecompilesBeforeAppRestart="max number of recompilations before appdomain is cycled" // Default: 15 recomplations
defaultLanguage="name of a language as specified in a <compiler/> tag below" // Default: VB
urlLinePragmas="[true|false]" // Default: false, meaning pragmas use physical paths
targetFramework="target framework moniker" eg ".NET Framework,Version=v4.0" // Default: null
controlBuilderInterceptorType="type name of ControlBuilderInterceptor implementation" //Default: ""
disableObsoleteWarnings="[true|false]" // Default: true
maxConcurrentCompilations="max number of concurrent assemblyBuilder compilations" // Default: 1
-->
<compilation debug="false" explicit="true" defaultLanguage="vb">
<!-- codeSubDirectories example:
Note that this section is only valid in web.config in the application root.
<codeSubDirectories>
<add directoryName="CodeSubDir1" />
<add directoryName="CodeSubDir2" />
</codeSubDirectories>
-->
<buildProviders>
<add extension=".aspx" type="System.Web.Compilation.PageBuildProvider" />
<add extension=".ascx" type="System.Web.Compilation.UserControlBuildProvider" />
<add extension=".master" type="System.Web.Compilation.MasterPageBuildProvider" />
<add extension=".asix" type="System.Web.Compilation.ImageGeneratorBuildProvider" />
<add extension=".asmx" type="System.Web.Compilation.WebServiceBuildProvider" />
<add extension=".ashx" type="System.Web.Compilation.WebHandlerBuildProvider" />
<add extension=".soap" type="System.Web.Compilation.WebServiceBuildProvider" />
<add extension=".resx" type="System.Web.Compilation.ResXBuildProvider" />
<add extension=".resources" type="System.Web.Compilation.ResourcesBuildProvider" />
<add extension=".wsdl" type="System.Web.Compilation.WsdlBuildProvider" />
<add extension=".xsd" type="System.Web.Compilation.XsdBuildProvider" />
</buildProviders>
<!-- folderLevelBuildProviders example:
<folderLevelBuildProviders>
<add type="MyBuildProvider, MyAssembly,Version=1.0.0.0,PublicKeyToken=TOKEN" />
</folderLevelBuildProviders>
-->
<assemblies>
<add assembly="mscorlib" />
<add assembly="System, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%ECMA_PUBLICKEY%" />
<add assembly="System.Configuration, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%MICROSOFT_PUBLICKEY%" />
<add assembly="System.Web, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%MICROSOFT_PUBLICKEY%" />
<add assembly="System.Data, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%ECMA_PUBLICKEY%" />
<add assembly="System.Web.Services, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%MICROSOFT_PUBLICKEY%" />
<add assembly="System.Xml, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%ECMA_PUBLICKEY%" />
<add assembly="System.Drawing, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%MICROSOFT_PUBLICKEY%" />
<add assembly="System.EnterpriseServices, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%MICROSOFT_PUBLICKEY%" />
<add assembly="System.Web.Mobile, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%MICROSOFT_PUBLICKEY%" />
<add assembly="*" />
</assemblies>
<expressionBuilders>
<add expressionPrefix="Resources" type="System.Web.Compilation.ResourceExpressionBuilder" />
<add expressionPrefix="ConnectionStrings" type="System.Web.Compilation.ConnectionStringsExpressionBuilder" />
<add expressionPrefix="AppSettings" type="System.Web.Compilation.AppSettingsExpressionBuilder" />
</expressionBuilders>
</compilation>
*/
public sealed class CompilationSection : ConfigurationSection {
private const string tempDirectoryAttributeName = "tempDirectory";
private const string assemblyPostProcessorTypeAttributeName = "assemblyPostProcessorType";
private const string controlBuilderInterceptorTypeAttributeName = "controlBuilderInterceptorType";
private static ConfigurationPropertyCollection _properties;
private static readonly ConfigurationProperty _propTempDirectory =
new ConfigurationProperty(tempDirectoryAttributeName, typeof(string),
String.Empty, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propDebug =
new ConfigurationProperty("debug", typeof(bool), false, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propStrict =
new ConfigurationProperty("strict", typeof(bool), false, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propExplicit =
new ConfigurationProperty("explicit", typeof(bool), true, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propBatch =
new ConfigurationProperty("batch", typeof(bool), true, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propOptimizeCompilations =
new ConfigurationProperty("optimizeCompilations", typeof(bool), false, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propBatchTimeout =
new ConfigurationProperty("batchTimeout",
typeof(TimeSpan),
TimeSpan.FromMinutes(15.0),
StdValidatorsAndConverters.TimeSpanSecondsOrInfiniteConverter,
StdValidatorsAndConverters.PositiveTimeSpanValidator,
ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propMaxBatchSize =
new ConfigurationProperty("maxBatchSize", typeof(int), 1000, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propMaxBatchGeneratedFileSize =
new ConfigurationProperty("maxBatchGeneratedFileSize", typeof(int), 1000, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propNumRecompilesBeforeAppRestart =
new ConfigurationProperty("numRecompilesBeforeAppRestart", typeof(int), 15, ConfigurationPropertyOptions.None);
#if !FEATURE_PAL // FEATURE_PAL does not support VisualBasic
private static readonly ConfigurationProperty _propDefaultLanguage =
new ConfigurationProperty("defaultLanguage", typeof(string), "vb", ConfigurationPropertyOptions.None);
#else // !FEATURE_PAL
private static readonly ConfigurationProperty _propDefaultLanguage =
new ConfigurationProperty("defaultLanguage", typeof(string),"c#",ConfigurationPropertyFlags.None);
#endif // !FEATURE_PAL
private static readonly ConfigurationProperty _propTargetFramework =
new ConfigurationProperty("targetFramework", typeof(string), null, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propCompilers =
new ConfigurationProperty("compilers", typeof(CompilerCollection), null, ConfigurationPropertyOptions.IsDefaultCollection);
private static readonly ConfigurationProperty _propAssemblies =
new ConfigurationProperty("assemblies", typeof(AssemblyCollection), null, ConfigurationPropertyOptions.IsDefaultCollection);
private static readonly ConfigurationProperty _propBuildProviders =
new ConfigurationProperty("buildProviders", typeof(BuildProviderCollection),
null, ConfigurationPropertyOptions.IsDefaultCollection);
private static readonly ConfigurationProperty _propFolderLevelBuildProviders =
new ConfigurationProperty("folderLevelBuildProviders", typeof(FolderLevelBuildProviderCollection),
null, ConfigurationPropertyOptions.IsDefaultCollection);
private static readonly ConfigurationProperty _propExpressionBuilders =
new ConfigurationProperty("expressionBuilders", typeof(ExpressionBuilderCollection),
null, ConfigurationPropertyOptions.IsDefaultCollection);
private static readonly ConfigurationProperty _propUrlLinePragmas =
new ConfigurationProperty("urlLinePragmas", typeof(bool), false, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propCodeSubDirs =
new ConfigurationProperty("codeSubDirectories", typeof(CodeSubDirectoriesCollection),
null, ConfigurationPropertyOptions.IsDefaultCollection);
private static readonly ConfigurationProperty _propAssemblyPreprocessorType =
new ConfigurationProperty(assemblyPostProcessorTypeAttributeName, typeof(string),
String.Empty, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propEnablePrefetchOptimization =
new ConfigurationProperty("enablePrefetchOptimization", typeof(bool), false, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propProfileGuidedOptimizations =
new ConfigurationProperty("profileGuidedOptimizations", typeof(ProfileGuidedOptimizationsFlags),
ProfileGuidedOptimizationsFlags.All, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propControlBuilderInterceptorType =
new ConfigurationProperty(controlBuilderInterceptorTypeAttributeName, typeof(string),
String.Empty, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propDisableObsoleteWarnings =
new ConfigurationProperty("disableObsoleteWarnings", typeof(bool),
true, ConfigurationPropertyOptions.None);
private static readonly ConfigurationProperty _propMaxConcurrentCompilations =
new ConfigurationProperty("maxConcurrentCompilations", typeof(int), 1, ConfigurationPropertyOptions.None);
const char fieldSeparator = ';';
private bool _referenceSet;
// _compilerLanguages : Hashtable <string, CompilerType>
// NOTE: This hashtable may contain either Compiler objects or CompilerType objects.
// It'll contain the later if the data has been read from config, but the particular
// language compiler type hasn't been resolved yet. Otherwise, it'll contain CompilerType objects.
private Hashtable _compilerLanguages;
// _compilerExtensions : Hashtable <string, CompilerType>
// NOTE: This hashtable may contain either Compiler objects or CompilerType objects.
// It'll contain the later if the data has been read from config, but the particular
// language compiler type hasn't been resolved yet. Otherwise, it'll contain CompilerType objects.
private Hashtable _compilerExtensions;
private long _recompilationHash = -1;
private bool _isRuntimeObject = false;
private Type _assemblyPostProcessorType;
private Type _controlBuilderInterceptorType;
private static readonly Lazy<ConcurrentDictionary<Assembly, string>> _assemblyNames =
new Lazy<ConcurrentDictionary<Assembly, string>>();
static CompilationSection() {
// Property initialization
_properties = new ConfigurationPropertyCollection();
_properties.Add(_propTempDirectory);
_properties.Add(_propDebug);
_properties.Add(_propStrict);
_properties.Add(_propExplicit);
_properties.Add(_propBatch);
_properties.Add(_propOptimizeCompilations);
_properties.Add(_propBatchTimeout);
_properties.Add(_propMaxBatchSize);
_properties.Add(_propMaxBatchGeneratedFileSize);
_properties.Add(_propNumRecompilesBeforeAppRestart);
_properties.Add(_propDefaultLanguage);
_properties.Add(_propTargetFramework);
_properties.Add(_propCompilers);
_properties.Add(_propAssemblies);
_properties.Add(_propBuildProviders);
_properties.Add(_propFolderLevelBuildProviders);
_properties.Add(_propExpressionBuilders);
_properties.Add(_propUrlLinePragmas);
_properties.Add(_propCodeSubDirs);
_properties.Add(_propAssemblyPreprocessorType);
_properties.Add(_propEnablePrefetchOptimization);
_properties.Add(_propProfileGuidedOptimizations);
_properties.Add(_propControlBuilderInterceptorType);
_properties.Add(_propDisableObsoleteWarnings);
_properties.Add(_propMaxConcurrentCompilations);
}
public CompilationSection() {
}
protected override ConfigurationPropertyCollection Properties {
get {
return _properties;
}
}
protected override object GetRuntimeObject() {
_isRuntimeObject = true;
return base.GetRuntimeObject();
}
[ConfigurationProperty(tempDirectoryAttributeName, DefaultValue = "")]
public string TempDirectory {
get {
return (string)base[_propTempDirectory];
}
set {
base[_propTempDirectory] = value;
}
}
// Used for error handling when there is a problem withe the temp dir
internal void GetTempDirectoryErrorInfo(out string tempDirAttribName,
out string configFileName, out int configLineNumber) {
tempDirAttribName = tempDirectoryAttributeName;
configFileName = ElementInformation.Properties[tempDirectoryAttributeName].Source;
configLineNumber = ElementInformation.Properties[tempDirectoryAttributeName].LineNumber;
}
[ConfigurationProperty("debug", DefaultValue = false)]
public bool Debug {
get {
return (bool)base[_propDebug];
}
set {
base[_propDebug] = value;
}
}
[ConfigurationProperty("strict", DefaultValue = false)]
public bool Strict {
get {
return (bool)base[_propStrict];
}
set {
base[_propStrict] = value;
}
}
[ConfigurationProperty("explicit", DefaultValue = true)]
public bool Explicit {
get {
return (bool)base[_propExplicit];
}
set {
base[_propExplicit] = value;
}
}
[ConfigurationProperty("batch", DefaultValue = true)]
public bool Batch {
get {
return (bool)base[_propBatch];
}
set {
base[_propBatch] = value;
}
}
[ConfigurationProperty("optimizeCompilations", DefaultValue = false)]
public bool OptimizeCompilations {
get {
return (bool)base[_propOptimizeCompilations];
}
set {
base[_propOptimizeCompilations] = value;
}
}
[ConfigurationProperty("urlLinePragmas", DefaultValue = false)]
public bool UrlLinePragmas {
get {
return (bool)base[_propUrlLinePragmas];
}
set {
base[_propUrlLinePragmas] = value;
}
}
[ConfigurationProperty("batchTimeout", DefaultValue = "00:15:00")]
[TimeSpanValidator(MinValueString="00:00:00", MaxValueString=TimeSpanValidatorAttribute.TimeSpanMaxValue)]
[TypeConverter(typeof(TimeSpanSecondsOrInfiniteConverter))]
public TimeSpan BatchTimeout {
get {
return (TimeSpan)base[_propBatchTimeout];
}
set {
base[_propBatchTimeout] = value;
}
}
[ConfigurationProperty("maxBatchSize", DefaultValue = 1000)]
public int MaxBatchSize {
get {
return (int)base[_propMaxBatchSize];
}
set {
base[_propMaxBatchSize] = value;
}
}
[ConfigurationProperty("maxBatchGeneratedFileSize", DefaultValue = 1000)]
public int MaxBatchGeneratedFileSize {
get {
return (int)base[_propMaxBatchGeneratedFileSize];
}
set {
base[_propMaxBatchGeneratedFileSize] = value;
}
}
[ConfigurationProperty("numRecompilesBeforeAppRestart", DefaultValue = 15)]
public int NumRecompilesBeforeAppRestart {
get {
return (int)base[_propNumRecompilesBeforeAppRestart];
}
set {
base[_propNumRecompilesBeforeAppRestart] = value;
}
}
[ConfigurationProperty("defaultLanguage", DefaultValue = "vb")]
public string DefaultLanguage {
get {
return (string)base[_propDefaultLanguage];
}
set {
base[_propDefaultLanguage] = value;
}
}
[ConfigurationProperty("targetFramework", DefaultValue = null)]
public string TargetFramework {
get {
return (string)base[_propTargetFramework];
}
set {
base[_propTargetFramework] = value;
}
}
[ConfigurationProperty("compilers")]
public CompilerCollection Compilers {
get {
return (CompilerCollection)base[_propCompilers];
}
}
[ConfigurationProperty("assemblies")]
public AssemblyCollection Assemblies {
get {
if (_isRuntimeObject || BuildManagerHost.InClientBuildManager) {
EnsureReferenceSet();
}
return GetAssembliesCollection();
}
}
private AssemblyCollection GetAssembliesCollection() {
return (AssemblyCollection)base[_propAssemblies];
}
[ConfigurationProperty("buildProviders")]
public BuildProviderCollection BuildProviders {
get {
return (BuildProviderCollection)base[_propBuildProviders];
}
}
private FolderLevelBuildProviderCollection GetFolderLevelBuildProviders() {
return (FolderLevelBuildProviderCollection)base[_propFolderLevelBuildProviders];
}
[ConfigurationProperty("folderLevelBuildProviders")]
public FolderLevelBuildProviderCollection FolderLevelBuildProviders {
get {
return GetFolderLevelBuildProviders();
}
}
[ConfigurationProperty("expressionBuilders")]
public ExpressionBuilderCollection ExpressionBuilders {
get {
return (ExpressionBuilderCollection)base[_propExpressionBuilders];
}
}
[ConfigurationProperty(assemblyPostProcessorTypeAttributeName, DefaultValue = "")]
public string AssemblyPostProcessorType {
get {
return (string)base[_propAssemblyPreprocessorType];
}
set {
base[_propAssemblyPreprocessorType] = value;
}
}
internal Type AssemblyPostProcessorTypeInternal {
get {
if (_assemblyPostProcessorType == null && !String.IsNullOrEmpty(AssemblyPostProcessorType)) {
lock (this) {
if (_assemblyPostProcessorType == null) {
// Only allow this in full trust
if (!HttpRuntime.HasUnmanagedPermission()) {
throw new ConfigurationErrorsException(SR.GetString(SR.Insufficient_trust_for_attribute, assemblyPostProcessorTypeAttributeName),
ElementInformation.Properties[assemblyPostProcessorTypeAttributeName].Source,
ElementInformation.Properties[assemblyPostProcessorTypeAttributeName].LineNumber);
}
Type assemblyPostProcessorType = ConfigUtil.GetType(AssemblyPostProcessorType, assemblyPostProcessorTypeAttributeName, this);
ConfigUtil.CheckBaseType(typeof(System.Web.Compilation.IAssemblyPostProcessor),
assemblyPostProcessorType, "assemblyPostProcessorType", this);
_assemblyPostProcessorType = assemblyPostProcessorType;
}
}
}
return _assemblyPostProcessorType;
}
}
[ConfigurationProperty("codeSubDirectories")]
public CodeSubDirectoriesCollection CodeSubDirectories {
get {
return (CodeSubDirectoriesCollection)base[_propCodeSubDirs];
}
}
[ConfigurationProperty("enablePrefetchOptimization", DefaultValue = false)]
public bool EnablePrefetchOptimization {
get {
return (bool)base[_propEnablePrefetchOptimization];
}
set {
base[_propEnablePrefetchOptimization] = value;
}
}
[ConfigurationProperty("profileGuidedOptimizations", DefaultValue = ProfileGuidedOptimizationsFlags.All)]
public ProfileGuidedOptimizationsFlags ProfileGuidedOptimizations {
get {
return (ProfileGuidedOptimizationsFlags)base[_propProfileGuidedOptimizations];
}
set {
base[_propProfileGuidedOptimizations] = value;
}
}
[ConfigurationProperty(controlBuilderInterceptorTypeAttributeName, DefaultValue = "")]
public string ControlBuilderInterceptorType {
get {
return (string)base[_propControlBuilderInterceptorType];
}
set {
base[_propControlBuilderInterceptorType] = value;
}
}
[ConfigurationProperty("disableObsoleteWarnings", DefaultValue = true)]
public bool DisableObsoleteWarnings {
get {
return (bool)base[_propDisableObsoleteWarnings];
}
set {
base[_propDisableObsoleteWarnings] = value;
}
}
[ConfigurationProperty("maxConcurrentCompilations", DefaultValue = 1)]
public int MaxConcurrentCompilations {
get {
return (int)base[_propMaxConcurrentCompilations];
}
set {
base[_propMaxConcurrentCompilations] = value;
}
}
private void EnsureCompilerCacheInit() {
if (_compilerLanguages == null) {
lock (this) {
if (_compilerLanguages == null) {
Hashtable compilerLanguages = new Hashtable(StringComparer.OrdinalIgnoreCase);
_compilerExtensions = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (Compiler compiler in Compilers) {
// Parse the semicolon separated lists
string[] languageList = compiler.Language.Split(fieldSeparator);
string[] extensionList = compiler.Extension.Split(fieldSeparator);
foreach (string language in languageList) {
compilerLanguages[language] = compiler;
}
foreach (string extension in extensionList) {
_compilerExtensions[extension] = compiler;
}
}
// Only assign it at the end to make sure everything was successful
_compilerLanguages = compilerLanguages;
}
}
}
}
/*
* Return a CompilerType that a extension maps to.
*/
internal CompilerType GetCompilerInfoFromExtension(string extension, bool throwOnFail) {
EnsureCompilerCacheInit();
// First, try the cache (i.e. old <compilers> section)
CompilerType compilerType;
object obj = _compilerExtensions[extension];
Compiler compiler = obj as Compiler;
if (compiler != null) {
compilerType = compiler.CompilerTypeInternal;
_compilerExtensions[extension] = compilerType;
}
else {
compilerType = obj as CompilerType;
}
if (compilerType == null) {
// If not, try the <codedom> section
if (CodeDomProvider.IsDefinedExtension(extension)) {
string language = CodeDomProvider.GetLanguageFromExtension(extension);
CompilerInfo ci = CodeDomProvider.GetCompilerInfo(language);
compilerType = new CompilerType(
ci.CodeDomProviderType, ci.CreateDefaultCompilerParameters());
// Cache it
_compilerExtensions[extension] = compilerType;
}
}
if (compilerType == null) {
if (!throwOnFail) return null;
// Unsupported extension: throw an exception
throw new HttpException(SR.GetString(SR.Invalid_lang_extension, extension));
}
// Clone it so the original is not modified
compilerType = compilerType.Clone();
// Set the value of the debug flag in the copy
compilerType.CompilerParameters.IncludeDebugInformation = Debug;
return compilerType;
}
/*
* Return a CompilerType that a language maps to.
*/
internal CompilerType GetCompilerInfoFromLanguage(string language) {
EnsureCompilerCacheInit();
// First, try the cache (i.e. old <compilers> section)
CompilerType compilerType;
object obj = _compilerLanguages[language];
Compiler compiler = obj as Compiler;
if (compiler != null) {
compilerType = compiler.CompilerTypeInternal;
_compilerLanguages[language] = compilerType;
}
else {
compilerType = obj as CompilerType;
}
if (compilerType == null) {
// Try the <codedom> section
if (CodeDomProvider.IsDefinedLanguage(language)) {
CompilerInfo ci = CodeDomProvider.GetCompilerInfo(language);
compilerType = new CompilerType(ci.CodeDomProviderType,
ci.CreateDefaultCompilerParameters());
// Cache it
_compilerLanguages[language] = compilerType;
}
}
if (compilerType == null) {
// Unsupported language: throw an exception
throw new HttpException(SR.GetString(SR.Invalid_lang, language));
}
// Only allow the use of compilerOptions when we have UnmanagedCode access (ASURT 73678)
CompilationUtil.CheckCompilerOptionsAllowed(compilerType.CompilerParameters.CompilerOptions,
true /*config*/, null, 0);
// Clone it so the original is not modified
compilerType = compilerType.Clone();
// Set the value of the debug flag in the copy
compilerType.CompilerParameters.IncludeDebugInformation = Debug;
return compilerType;
}
// This will only set the section pointer
private void EnsureReferenceSet() {
if (!_referenceSet) {
foreach (AssemblyInfo ai in GetAssembliesCollection()) {
ai.SetCompilationReference(this);
}
_referenceSet = true;
}
}
/// <summary>
/// Returns the original assembly name associated with the loaded assembly.
/// Returns Assembly.FullName if not found.
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
internal static string GetOriginalAssemblyName(Assembly a) {
string name = null;
if (!_assemblyNames.Value.TryGetValue(a, out name)) {
// If the assembly is not found in the dictionary, just
// return Assembly.FullName.
name = a.FullName;
}
return name;
}
internal Assembly[] LoadAssembly(AssemblyInfo ai) {
Assembly[] assemblies = null;
if (ai.Assembly == "*") {
assemblies = LoadAllAssembliesFromAppDomainBinDirectory();
}
else {
Assembly a;
a = LoadAssemblyHelper(ai.Assembly, false);
if (a != null) {
assemblies = new Assembly[1];
assemblies[0] = a;
RecordAssembly(ai.Assembly, a);
}
}
return assemblies;
}
internal static Assembly LoadAndRecordAssembly(AssemblyName name) {
Assembly a = Assembly.Load(name);
RecordAssembly(name.FullName, a);
return a;
}
internal static void RecordAssembly(string assemblyName, Assembly a) {
// For each Assembly that we load, keep track of its original
// full name as specified in the config.
if (!_assemblyNames.Value.ContainsKey(a)) {
_assemblyNames.Value.TryAdd(a, assemblyName);
}
}
internal Assembly LoadAssembly(string assemblyName, bool throwOnFail) {
// The trust should always be set before we load any assembly (VSWhidbey 317295)
System.Web.Util.Debug.Assert(HttpRuntime.TrustLevel != null);
try {
// First, try to just load the assembly
Assembly a = Assembly.Load(assemblyName);
// Record the original assembly name that was used to load this assembly.
RecordAssembly(assemblyName, a);
return a;
}
catch {
AssemblyName asmName = new AssemblyName(assemblyName);
// Check if it's simply named
Byte[] publicKeyToken = asmName.GetPublicKeyToken();
if ((publicKeyToken == null || publicKeyToken.Length == 0) && asmName.Version == null) {
EnsureReferenceSet();
// It is simply named. Go through all the assemblies from
// the <assemblies> section, and if we find one that matches
// the simple name, return it (ASURT 100546)
foreach (AssemblyInfo ai in GetAssembliesCollection()) {
Assembly[] a = ai.AssemblyInternal;
if (a != null) {
for (int i = 0; i < a.Length; i++) {
// use new AssemblyName(FullName).Name
// instead of a.GetName().Name, because GetName() does not work in medium trust
if (StringUtil.EqualsIgnoreCase(asmName.Name, new AssemblyName(a[i].FullName).Name)) {
return a[i];
}
}
}
}
}
if (throwOnFail) {
throw;
}
}
return null;
}
private Assembly LoadAssemblyHelper(string assemblyName, bool starDirective) {
// The trust should always be set before we load any assembly (VSWhidbey 317295)
System.Web.Util.Debug.Assert(HttpRuntime.TrustLevel != null);
Assembly retAssembly = null;
// Load the assembly and add it to the dictionary.
try {
retAssembly = System.Reflection.Assembly.Load(assemblyName);
}
catch (Exception e) {
// Check if this assembly came from the '*' directive
bool ignoreException = false;
if (starDirective) {
int hresult = System.Runtime.InteropServices.Marshal.GetHRForException(e);
// This is expected to fail for unmanaged DLLs that happen
// to be in the bin dir. Ignore them.
// Also, if the DLL is not an assembly, ignore the exception (ASURT 93073, VSWhidbey 319486)
// Test for COR_E_ASSEMBLYEXPECTED=0x80131018=-2146234344
if (hresult == -2146234344) {
ignoreException = true;
}
}
if (BuildManager.IgnoreBadImageFormatException) {
var badImageFormatException = e as BadImageFormatException;
if (badImageFormatException != null) {
ignoreException = true;
}
}
if (!ignoreException) {
string Message = e.Message;
if (String.IsNullOrEmpty(Message)) {
// try and make a better message than empty string
if (e is FileLoadException) {
Message = SR.GetString(SR.Config_base_file_load_exception_no_message, "assembly");
}
else if (e is BadImageFormatException) {
Message = SR.GetString(SR.Config_base_bad_image_exception_no_message, assemblyName);
}
else {
Message = SR.GetString(SR.Config_base_report_exception_type, e.GetType().ToString()); // at least this is better than no message
}
}
// default to section if the assembly is not in the collection
// which may happen it the assembly is being loaded from the bindir
// and not named in configuration.
String source = ElementInformation.Properties["assemblies"].Source;
int lineNumber = ElementInformation.Properties["assemblies"].LineNumber;
// If processing the * directive, look up the line information for it
if (starDirective)
assemblyName = "*";
if (Assemblies[assemblyName] != null) {
source = Assemblies[assemblyName].ElementInformation.Source;
lineNumber = Assemblies[assemblyName].ElementInformation.LineNumber;
}
throw new ConfigurationErrorsException(Message, e, source, lineNumber);
}
}
System.Web.Util.Debug.Trace("LoadAssembly", "Successfully loaded assembly '" + assemblyName + "'");
return retAssembly;
}
internal Assembly[] LoadAllAssembliesFromAppDomainBinDirectory() {
// Get the path to the bin directory
string binPath = HttpRuntime.BinDirectoryInternal;
FileInfo[] binDlls;
Assembly assembly = null;
Assembly[] assemblies = null;
ArrayList list;
if (!FileUtil.DirectoryExists(binPath)) {
// This is expected to fail if there is no 'bin' dir
System.Web.Util.Debug.Trace("Template", "Failed to access bin dir \"" + binPath + "\"");
}
else {
DirectoryInfo binPathDirectory = new DirectoryInfo(binPath);
// Get a list of all the DLL's in the bin directory
binDlls = binPathDirectory.GetFiles("*.dll");
if (binDlls.Length > 0) {
list = new ArrayList(binDlls.Length);
for (int i = 0; i < binDlls.Length; i++) {
string assemblyName = Util.GetAssemblyNameFromFileName(binDlls[i].Name);
// Don't autoload generated assemblies in bin (VSWhidbey 467936)
if (assemblyName.StartsWith(BuildManager.WebAssemblyNamePrefix, StringComparison.Ordinal))
continue;
if (!GetAssembliesCollection().IsRemoved(assemblyName)) {
assembly = LoadAssemblyHelper(assemblyName, true);
}
if (assembly != null) {
list.Add(assembly);
}
}
assemblies = (System.Reflection.Assembly[])list.ToArray(typeof(System.Reflection.Assembly));
}
}
if (assemblies == null) {
// If there were no assemblies loaded, return a zero-length array
assemblies = new Assembly[0];
}
return assemblies;
}
internal long RecompilationHash {
get {
if (_recompilationHash == -1) {
lock (this) {
if (_recompilationHash == -1) {
_recompilationHash = CompilationUtil.GetRecompilationHash(this);
}
}
}
return _recompilationHash;
}
}
protected override void PostDeserialize() {
// check to see if the _propCodeSubDirs was defined below the app level
WebContext context = EvaluationContext.HostingContext as WebContext;
if (context != null) {
if (context.ApplicationLevel == WebApplicationLevel.BelowApplication) {
if (CodeSubDirectories.ElementInformation.IsPresent) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Config_element_below_app_illegal,
_propCodeSubDirs.Name), CodeSubDirectories.ElementInformation.Source, CodeSubDirectories.ElementInformation.LineNumber);
}
if (BuildProviders.ElementInformation.IsPresent) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Config_element_below_app_illegal,
_propBuildProviders.Name), BuildProviders.ElementInformation.Source, BuildProviders.ElementInformation.LineNumber);
}
if (FolderLevelBuildProviders.ElementInformation.IsPresent) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Config_element_below_app_illegal,
_propFolderLevelBuildProviders.Name), FolderLevelBuildProviders.ElementInformation.Source, FolderLevelBuildProviders.ElementInformation.LineNumber);
}
}
}
}
internal Type ControlBuilderInterceptorTypeInternal {
get {
if (_controlBuilderInterceptorType == null && !String.IsNullOrWhiteSpace(ControlBuilderInterceptorType)) {
lock (this) {
if (_controlBuilderInterceptorType == null) {
_controlBuilderInterceptorType = CompilationUtil.LoadTypeWithChecks(ControlBuilderInterceptorType, typeof(ControlBuilderInterceptor), null, this, controlBuilderInterceptorTypeAttributeName);
}
}
}
return _controlBuilderInterceptorType;
}
}
// This is called as the last step of the deserialization process before the newly created section is seen by the consumer.
// We can use it to change defaults on-the-fly.
protected override void SetReadOnly() {
// Unless overridden, set <compilation targetFramework="4.5" />
ConfigUtil.SetFX45DefaultValue(this, _propTargetFramework, BinaryCompatibility.Current.TargetFramework.ToString());
base.SetReadOnly();
}
}
}