mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
247 lines
9.5 KiB
C#
247 lines
9.5 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Configuration;
|
|
using System.Web;
|
|
using System.Web.Compilation;
|
|
using System.Web.Configuration;
|
|
using System.Web.Hosting;
|
|
using Microsoft.Build.Utilities;
|
|
|
|
// Helper class to use 2.0 root config as necessary. Each helper method will
|
|
// go through RuntimeConfig (the original code path), except in the
|
|
// case of building and targeting 2.0/3.5.
|
|
internal class MTConfigUtil {
|
|
|
|
private static readonly ConcurrentDictionary<Tuple<Type, VirtualPath>, ConfigurationSection> s_sections =
|
|
new ConcurrentDictionary<Tuple<Type, VirtualPath>, ConfigurationSection>();
|
|
|
|
private static readonly ConcurrentDictionary<VirtualPath, Configuration> s_configurations =
|
|
new ConcurrentDictionary<VirtualPath, Configuration>();
|
|
|
|
private static string s_machineConfigPath;
|
|
private static VirtualPath s_appVirtualPath;
|
|
|
|
// We only need to use the root config of 2.0 if we are building (and
|
|
// not during runtime) and targeting 2.0 or 3.5.
|
|
static private bool? s_useMTConfig;
|
|
static private bool UseMTConfig {
|
|
get {
|
|
if (s_useMTConfig == null) {
|
|
s_useMTConfig = BuildManagerHost.InClientBuildManager &&
|
|
(MultiTargetingUtil.IsTargetFramework20 || MultiTargetingUtil.IsTargetFramework35);
|
|
}
|
|
return s_useMTConfig.Value;
|
|
}
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetAppConfig().Profile;
|
|
static internal ProfileSection GetProfileAppConfig() {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetAppConfig().Profile;
|
|
}
|
|
return GetAppConfig<ProfileSection>();
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetAppConfig().Pages;
|
|
static internal PagesSection GetPagesAppConfig() {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetAppConfig().Pages;
|
|
}
|
|
return GetAppConfig<PagesSection>();
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig().Pages;
|
|
static internal PagesSection GetPagesConfig() {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig().Pages;
|
|
}
|
|
return GetConfig<PagesSection>();
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig(string).Pages
|
|
static internal PagesSection GetPagesConfig(string vpath) {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig(vpath).Pages;
|
|
}
|
|
return GetConfig<PagesSection>(vpath);
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig(VirtualPath).Pages
|
|
static internal PagesSection GetPagesConfig(VirtualPath vpath) {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig(vpath).Pages;
|
|
}
|
|
return GetConfig<PagesSection>(vpath);
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig(HttpContext).Pages
|
|
static internal PagesSection GetPagesConfig(HttpContext context) {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig(context).Pages;
|
|
}
|
|
return GetConfig<PagesSection>(context);
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig().Compilation
|
|
static internal CompilationSection GetCompilationConfig() {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig().Compilation;
|
|
}
|
|
return GetConfig<CompilationSection>();
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetAppConfig().Compilation
|
|
static internal CompilationSection GetCompilationAppConfig() {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetAppConfig().Compilation;
|
|
}
|
|
return GetAppConfig<CompilationSection>();
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig(string).Compilation
|
|
static internal CompilationSection GetCompilationConfig(string vpath) {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig(vpath).Compilation;
|
|
}
|
|
return GetConfig<CompilationSection>(vpath);
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig(VirtualPath).Compilation
|
|
static internal CompilationSection GetCompilationConfig(VirtualPath vpath) {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig(vpath).Compilation;
|
|
}
|
|
return GetConfig<CompilationSection>(vpath);
|
|
}
|
|
|
|
// Counterpart for RuntimeConfig.GetConfig(HttpContext).Compilation
|
|
static internal CompilationSection GetCompilationConfig(HttpContext context) {
|
|
if (!UseMTConfig) {
|
|
return RuntimeConfig.GetConfig(context).Compilation;
|
|
}
|
|
return GetConfig<CompilationSection>(context);
|
|
}
|
|
|
|
// Counterpart to RuntimeConfig.GetConfig()
|
|
static private S GetConfig<S>() where S : ConfigurationSection {
|
|
HttpContext context = HttpContext.Current;
|
|
if (context != null) {
|
|
return GetConfig<S>(context);
|
|
}
|
|
else {
|
|
return GetAppConfig<S>();
|
|
}
|
|
}
|
|
|
|
// Counterpart to RuntimeConfig.GetAppConfig()
|
|
static private S GetAppConfig<S>() where S : ConfigurationSection {
|
|
return GetConfig<S>((VirtualPath) null);
|
|
}
|
|
|
|
// Counterpart to RuntimeConfig.GetConfig(HttpContext)
|
|
static private S GetConfig<S>(HttpContext context) where S : ConfigurationSection {
|
|
return GetConfig<S>(context.ConfigurationPath);
|
|
}
|
|
|
|
// Counterpart to RuntimeConfig.GetConfig(string)
|
|
static private S GetConfig<S>(string vpath) where S : ConfigurationSection{
|
|
return GetConfig<S>(VirtualPath.CreateNonRelativeAllowNull(vpath));
|
|
}
|
|
|
|
// Counterpart to RuntimeConfig.GetConfig(VirtualPath)
|
|
static private S GetConfig<S>(VirtualPath vpath) where S : ConfigurationSection {
|
|
Tuple<Type, VirtualPath> key = new Tuple<Type, VirtualPath>(typeof(S), vpath);
|
|
ConfigurationSection result;
|
|
if (!s_sections.TryGetValue(key, out result)) {
|
|
result = GetConfigHelper<S>(vpath);
|
|
s_sections.TryAdd(key, result);
|
|
}
|
|
return result as S;
|
|
}
|
|
|
|
// 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));
|
|
}
|
|
|
|
static private string MachineConfigPath {
|
|
get {
|
|
if (s_machineConfigPath == null) {
|
|
s_machineConfigPath = ToolLocationHelper.GetPathToDotNetFrameworkFile(@"config\machine.config", TargetDotNetFrameworkVersion.Version20);
|
|
if (string.IsNullOrEmpty(s_machineConfigPath)) {
|
|
string message = SR.GetString(SR.Downlevel_requires_35);
|
|
throw new InvalidOperationException(message);
|
|
}
|
|
}
|
|
return s_machineConfigPath;
|
|
}
|
|
}
|
|
|
|
static private Configuration GetConfiguration(VirtualPath vpath, string physicalPath) {
|
|
Configuration result;
|
|
if (!s_configurations.TryGetValue(vpath, out result)) {
|
|
result = GetConfigurationHelper(vpath, physicalPath);
|
|
s_configurations.TryAdd(vpath, result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static private Configuration GetConfigurationHelper(VirtualPath vpath, string physicalPath) {
|
|
// Set up the configuration file map
|
|
string machineConfigPath = MachineConfigPath;
|
|
WebConfigurationFileMap fileMap = new WebConfigurationFileMap(machineConfigPath);
|
|
|
|
// Set up file maps for the current directory and parent directories up to application root
|
|
VirtualPath currentVPath = vpath;
|
|
while (currentVPath != null && currentVPath.IsWithinAppRoot) {
|
|
string vpathString = currentVPath.VirtualPathStringNoTrailingSlash;
|
|
if (physicalPath == null) {
|
|
physicalPath = HostingEnvironment.MapPath(currentVPath);
|
|
}
|
|
fileMap.VirtualDirectories.Add(vpathString, new VirtualDirectoryMapping(physicalPath, IsAppRoot(currentVPath)));
|
|
currentVPath = currentVPath.Parent;
|
|
physicalPath = null;
|
|
}
|
|
|
|
Configuration config = WebConfigurationManager.OpenMappedWebConfiguration(fileMap, vpath.VirtualPathStringNoTrailingSlash, HostingEnvironment.SiteName);
|
|
return config;
|
|
}
|
|
|
|
static private bool IsAppRoot(VirtualPath path) {
|
|
if (s_appVirtualPath == null) {
|
|
s_appVirtualPath = VirtualPath.Create(HttpRuntime.AppDomainAppVirtualPathObject.VirtualPathStringNoTrailingSlash);
|
|
}
|
|
|
|
var vpath = VirtualPath.Create(path.VirtualPathStringNoTrailingSlash);
|
|
return s_appVirtualPath.Equals(vpath);
|
|
}
|
|
|
|
}
|