private static Configuration GetWebConfig()
{
var vdm = new VirtualDirectoryMapping(_settings.SourceDirectory, true);
var wcfm = new WebConfigurationFileMap();
wcfm.VirtualDirectories.Add("/", vdm);
return(WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/"));
}
public TSection GetSection <TSection>(string sectionName) where TSection : class
{
var map = new WebConfigurationFileMap();
map.VirtualDirectories.Add("/", GetVDirMapping());
var configuration = WebConfigurationManager.OpenMappedWebConfiguration(map, "/");
return(configuration.GetSection(sectionName) as TSection);
}
private static Configuration _OpenConfigFile(string VirtualConfigPath)
{
lock (_threadsafe)
{
WebConfigurationFileMap webConfigFileMap = new WebConfigurationFileMap();
Configuration config = null;
config = WebConfigurationManager.OpenWebConfiguration(VirtualConfigPath);
return(config);
}
}
/// <summary>
/// Adds standard configuration from specified web application.
/// This method is similar to <see cref="ConfigurationSourcesBuilderExtensions.AddConfigurationManagerConfiguration"/> but work on a different application context:
/// It is needed for utility applications that reference the generated Rhetos applications and use it's runtime components.
/// This method load's the Rhetos application's configuration, while <see cref="ConfigurationSourcesBuilderExtensions.AddConfigurationManagerConfiguration"/> loads the current utility application's configuration.
/// When executed from the generated Rhetos application, it should yield same result as <see cref="ConfigurationSourcesBuilderExtensions.AddConfigurationManagerConfiguration"/>.
/// </summary>
public static IConfigurationBuilder AddWebConfiguration(this IConfigurationBuilder builder, string webRootPath)
{
webRootPath = Path.GetFullPath(webRootPath);
VirtualDirectoryMapping vdm = new VirtualDirectoryMapping(webRootPath, true);
WebConfigurationFileMap wcfm = new WebConfigurationFileMap();
wcfm.VirtualDirectories.Add("/", vdm);
System.Configuration.Configuration configuration = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/");
builder.Add(new ConfigurationFileSource(configuration));
return(builder);
}
public static Configuration GetWebConfig(string wwwPath)
{
var webConfigFile = new FileInfo("Web.config");
var vdm = new VirtualDirectoryMapping(wwwPath, true, webConfigFile.Name);
var wcfm = new WebConfigurationFileMap();
wcfm.VirtualDirectories.Add("/", vdm);
var siteName = "Sandbox";
return(WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/", siteName));
}
private void EnsureInitialized()
{
if (_configuration != null)
{
return;
}
var webConfigurationFileMap = new WebConfigurationFileMap();
webConfigurationFileMap.VirtualDirectories.Add(VirtualDirectory, new VirtualDirectoryMapping(_path, true));
_configuration = WebConfigurationManager.OpenMappedWebConfiguration(webConfigurationFileMap, VirtualDirectory);
}
public override void Initialize(RazorHost razorHost, IDictionary <string, string> directives)
{
string projectPath = GetProjectRoot(razorHost.ProjectRelativePath, razorHost.FullPath).TrimEnd(Path.DirectorySeparatorChar);
string currentPath = razorHost.FullPath;
string directoryVirtualPath = null;
var configFileMap = new WebConfigurationFileMap();
var virtualDirectories = configFileMap.VirtualDirectories;
while (!currentPath.Equals(projectPath, StringComparison.OrdinalIgnoreCase))
{
currentPath = Path.GetDirectoryName(currentPath);
string relativePath = currentPath.Substring(projectPath.Length);
bool isAppRoot = currentPath.Equals(projectPath, StringComparison.OrdinalIgnoreCase);
string virtualPath = relativePath.Replace('\\', '/');
if (virtualPath.Length == 0)
{
virtualPath = "/";
}
directoryVirtualPath = directoryVirtualPath ?? virtualPath;
virtualDirectories.Add(virtualPath, new VirtualDirectoryMapping(currentPath, isAppRoot: isAppRoot));
}
try
{
var config = WebConfigurationManager.OpenMappedWebConfiguration(configFileMap, directoryVirtualPath);
RazorPagesSection section = config.GetSection(RazorPagesSection.SectionName) as RazorPagesSection;
if (section != null)
{
string baseType = section.PageBaseType;
if (!DefaultBaseType.Equals(baseType, StringComparison.OrdinalIgnoreCase))
{
_transformers.Add(new SetBaseType(baseType));
}
if (section != null)
{
foreach (NamespaceInfo n in section.Namespaces)
{
razorHost.NamespaceImports.Add(n.Namespace);
}
}
}
}
catch (IndexOutOfRangeException)
{
// Bug in Mono framework.
// Configure namespaces using the RazorGenerator directives file instead.
}
base.Initialize(razorHost, directives);
}
public static System.Configuration.Configuration LoadWebConfigForUnitTests()
{
var unitTestAssembly = typeof(WebConfigLoaderForUnitTests).Assembly;
var directoryName = Path.GetDirectoryName(unitTestAssembly.Location);
var assemblyPath = directoryName.Replace(@"file:\", string.Empty);
var webConfigFile = new FileInfo(Path.Combine(assemblyPath, unitTestAssembly.GetName().Name + ".dll.config"));
var virtualDirectoryMapping = new VirtualDirectoryMapping(webConfigFile.DirectoryName, true, webConfigFile.Name);
var webConfigurationFileMap = new WebConfigurationFileMap();
webConfigurationFileMap.VirtualDirectories.Add("/", virtualDirectoryMapping);
return(WebConfigurationManager.OpenMappedWebConfiguration(webConfigurationFileMap, "/"));
}
public virtual void SetUp()
{
var rootPathProvider = new InvoiceGenRootPathProvider();
var webConfigFile = new FileInfo(Path.Combine(rootPathProvider.GetRootPath(), "web.config"));
var virtualDirectoryMapping = new VirtualDirectoryMapping(webConfigFile.DirectoryName, true, webConfigFile.Name);
var webConfigurationFileMap = new WebConfigurationFileMap();
webConfigurationFileMap.VirtualDirectories.Add("/", virtualDirectoryMapping);
var configuration = WebConfigurationManager.OpenMappedWebConfiguration(webConfigurationFileMap, "/");
_sut = CompositionRoot.Compose(configuration);
}
static StateRuntime()
{
WebConfigurationFileMap fileMap = new WebConfigurationFileMap();
UserMapPath configMapPath = new UserMapPath(fileMap);
HttpConfigurationSystem.EnsureInit(configMapPath, false, true);
StateApplication customApplication = new StateApplication();
HttpApplicationFactory.SetCustomApplication(customApplication);
PerfCounters.OpenStateCounters();
ResetStateServerCounters();
}
/// <summary>
/// Load web.config from a diferent context (like a script)
/// </summary>
/// <returns></returns>
private static Configuration GetConfiguration()
{
var path = Path.GetFullPath(
Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"..\\Web.config"));
var configFile = new FileInfo(path);
var vdm = new VirtualDirectoryMapping(configFile.DirectoryName, true, configFile.Name);
var wcfm = new WebConfigurationFileMap();
wcfm.VirtualDirectories.Add("/", vdm);
return(WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/"));
}
public void OverrideAppSettingsWithEnvironmentVars()
{
throw new NotImplementedException("Not implemented as WebConfigurationManager seems buggy in Mono 3.2.4");
string directory = Path.GetDirectoryName(Path.GetFullPath(configFile));
WebConfigurationFileMap wcfm = new WebConfigurationFileMap();
VirtualDirectoryMapping vdm = new VirtualDirectoryMapping(directory, true, "Web.config");
wcfm.VirtualDirectories.Add("/", vdm);
//WebConfigurationManager seems bugging in Mono 3.2.4
Configuration webConfig = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/");
}
/// <summary>
/// 获取标准Web应用程序的配置信息，合并Web.config和 global配置文件
/// </summary>
/// <param name="machineConfigPath">global配置文件地址</param>
/// <returns>Web.config和global配置文件合并后的Configuration对象</returns>
private static System.Configuration.Configuration GetStandardWebConfiguration(string machineConfigPath)
{
System.Configuration.Configuration config;
WebConfigurationFileMap webFileMap = new WebConfigurationFileMap()
{
MachineConfigFilename = machineConfigPath
};
VirtualDirectoryMapping vDirMap = new VirtualDirectoryMapping(HttpContext.Current.Request.PhysicalApplicationPath, true);
webFileMap.VirtualDirectories.Add("/", vDirMap);
config = WebConfigurationManager.OpenMappedWebConfiguration(webFileMap, "/",
System.Web.Hosting.HostingEnvironment.SiteName);
return(config);
}
public RazorParser(Workspace workspace, CancellationToken cancellationToken, Compilation compilation)
{
_workItems = new BlockingCollection <RazorTextLoader>();
_workspace = workspace;
_compilation = compilation;
_configMap = new WebConfigurationFileMap {
VirtualDirectories = { { "/", new VirtualDirectoryMapping(compilation.CurrentDirectory.FullName, true) } }
};
_cancellationToken = cancellationToken;
_backgroundWorkers = new Lazy <Task>(
() => _cancellationToken.IsCancellationRequested
? Task.CompletedTask
: Task.WhenAll(Enumerable.Range(0, Environment.ProcessorCount).Select(_ => Task.Run(BackgroundWorker, _cancellationToken))),
LazyThreadSafetyMode.ExecutionAndPublication);
}
public static void setReserveTimeUnit(int hr)
{
Configuration c = null;
if (HostingEnvironment.ApplicationVirtualPath == "/")
{
c = WebConfigurationManager.OpenWebConfiguration("~/web.config");
}
WebConfigurationFileMap fileMap = CreateFileMap(HostingEnvironment.ApplicationVirtualPath);
c = WebConfigurationManager.OpenMappedWebConfiguration(fileMap, HostingEnvironment.ApplicationVirtualPath);
c.AppSettings.Settings["reserveTimeUnit"].Value = hr.ToString();
c.Save();
}
protected override void Execute(CodeActivityContext context)
{
Configuration config = null;
if (IsWebsite.Get(context))
{
var configFile = new FileInfo(ConfigFilename.Get(context));
var vdm = new VirtualDirectoryMapping(configFile.DirectoryName, true, configFile.Name);
var wcfm = new WebConfigurationFileMap();
wcfm.VirtualDirectories.Add("/", vdm);
config = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/");
}
else
{
config = ConfigurationManager.OpenMappedExeConfiguration(new ExeConfigurationFileMap {
ExeConfigFilename = ConfigFilename.Get(context)
}, ConfigurationUserLevel.None);
}
ConfigurationSection section = config.GetSection(Section.Get(context));
section.SectionInformation.ProtectSection("RSAProtectedConfigurationProvider");
config.Save();
var console = context.GetExtension <ActivityConsole>();
if (console == null)
{
console = new ActivityConsole();
}
console.WriteLine(string.Format("Encrypted section '{0}' in '{1}'", Section.Get(context), ConfigFilename.Get(context)));
console.WriteLine("");
string username = Username.Get(context);
if (!string.IsNullOrEmpty(username))
{
Helpers.CommandLine cmdExecutor = new CommandLine();
string output = string.Empty;
int exitCode = cmdExecutor.Execute(string.Format("{0}\\{1}", Helpers.FrameworkHelper.GetDotNetInstallationFolder(), "aspnet_regiis"), string.Format("-pa \"NetFrameworkConfigurationKey\" \"{0}\"", username), out output);
if (exitCode != 0 || !output.Contains("Succeeded!"))
{
throw new ArgumentException(string.Format("Failed to set Encryption key security privileges for user '{0}'\n{1}", username, output));
}
console.WriteLine(string.Format("Successfully set read access to Encryption key for user '{0}'.", username));
}
}
RazorEngineHost CreateRazorHost(string fileName)
{
string virtualPath = "~/Views/Default.cshtml";
if (project != null)
{
virtualPath = project.LocalToVirtualPath(fileName);
}
WebPageRazorHost host = null;
// Try to create host using web.config file
var webConfigMap = new WebConfigurationFileMap();
var vdm = new VirtualDirectoryMapping(project.BaseDirectory.Combine("Views"), true, "web.config");
webConfigMap.VirtualDirectories.Add("/", vdm);
Configuration configuration;
try {
configuration = WebConfigurationManager.OpenMappedWebConfiguration(webConfigMap, "/");
} catch {
configuration = null;
}
if (configuration != null)
{
var rws = configuration.GetSectionGroup(RazorWebSectionGroup.GroupName) as RazorWebSectionGroup;
if (rws != null)
{
host = WebRazorHostFactory.CreateHostFromConfig(rws, virtualPath, fileName);
host.DesignTimeMode = true;
}
}
if (host == null)
{
host = new MvcWebPageRazorHost(virtualPath, fileName)
{
DesignTimeMode = true
};
// Add default namespaces from Razor section
host.NamespaceImports.Add("System.Web.Mvc");
host.NamespaceImports.Add("System.Web.Mvc.Ajax");
host.NamespaceImports.Add("System.Web.Mvc.Html");
host.NamespaceImports.Add("System.Web.Routing");
}
return(host);
}
IConfigMapPath IConfigMapPathFactory.Create(string virtualPath, string physicalPath)
{
WebConfigurationFileMap webFileMap = new WebConfigurationFileMap();
VirtualPath vpath = VirtualPath.Create(virtualPath);
// Application path
webFileMap.VirtualDirectories.Add(vpath.VirtualPathStringNoTrailingSlash,
new VirtualDirectoryMapping(physicalPath, true));
// Client script file path
webFileMap.VirtualDirectories.Add(
HttpRuntime.AspClientScriptVirtualPath,
new VirtualDirectoryMapping(HttpRuntime.AspClientScriptPhysicalPathInternal, false));
return(new UserMapPath(webFileMap));
}
public void SetCredentials()
{
var webConfigurationFileMap = new WebConfigurationFileMap();
webConfigurationFileMap.VirtualDirectories.Add(_path, new VirtualDirectoryMapping(_path, isAppRoot: true));
var webConfig = WebConfigurationManager.OpenMappedWebConfiguration(webConfigurationFileMap, string.Empty);
var map = new ExeConfigurationFileMap {
ExeConfigFilename = @_path
};
var configfile = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
var test = WebConfigurationManager.AppSettings[""];
var a = webConfig.GetSection("appSettings");
//TODO: get this working so I dont have to hardcode the key and secret...
//_secret = ConfigurationManager.AppSettings["KrakenSecret"];
}
/// <summary>
/// Saves the connection string as a proper .net ConnectionString and the legacy AppSettings key/value.
/// </summary>
/// <remarks>
/// Saves the ConnectionString in the very nasty 'medium trust'-supportive way.
/// </remarks>
/// <param name="connectionString"></param>
/// <param name="providerName"></param>
private void SaveConnectionString(string connectionString, string providerName)
{
//Set the connection string for the new datalayer
var connectionStringSettings = string.IsNullOrEmpty(providerName)
? new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
connectionString)
: new ConnectionStringSettings(GlobalSettings.UmbracoConnectionName,
connectionString, providerName);
_connectionString = connectionString;
_providerName = providerName;
var webConfig = new WebConfigurationFileMap();
var vDir = GlobalSettings.FullpathToRoot;
foreach (VirtualDirectoryMapping v in webConfig.VirtualDirectories)
{
if (v.IsAppRoot)
{
vDir = v.PhysicalDirectory;
}
}
var fileName = Path.Combine(vDir, "web.config");
var xml = XDocument.Load(fileName, LoadOptions.PreserveWhitespace);
var connectionstrings = xml.Root.Descendants("connectionStrings").Single();
// Update connectionString if it exists, or else create a new appSetting for the given key and value
var setting = connectionstrings.Descendants("add").FirstOrDefault(s => s.Attribute("name").Value == GlobalSettings.UmbracoConnectionName);
if (setting == null)
{
connectionstrings.Add(new XElement("add",
new XAttribute("name", GlobalSettings.UmbracoConnectionName),
new XAttribute("connectionString", connectionStringSettings),
new XAttribute("providerName", providerName)));
}
else
{
setting.Attribute("connectionString").Value = connectionString;
setting.Attribute("providerName").Value = providerName;
}
xml.Save(fileName, SaveOptions.DisableFormatting);
LogHelper.Info <DatabaseContext>("Configured a new ConnectionString using the '" + providerName + "' provider.");
}
private static string GetFullWebConfigFileName()
{
var webConfig = new WebConfigurationFileMap();
var vDir = FullpathToRoot;
foreach (VirtualDirectoryMapping v in webConfig.VirtualDirectories)
{
if (v.IsAppRoot)
{
vDir = v.PhysicalDirectory;
}
}
var fileName = System.IO.Path.Combine(vDir, "web.config");
return(fileName);
}
public static System.Configuration.Configuration GetConfigFile()
{
if (websiteConfig == null)
{
WebConfigurationFileMap fileMap = new WebConfigurationFileMap();
fileMap.VirtualDirectories.Add("/", new VirtualDirectoryMapping(HttpContext.Current.Server.MapPath("~"), true));
try
{
websiteConfig = WebConfigurationManager.OpenMappedWebConfiguration(fileMap, "/");
}
catch (ArgumentOutOfRangeException)
{
websiteConfig = WebConfigurationManager.OpenMappedWebConfiguration(fileMap, "/", "t");
}
}
return(websiteConfig);
}
private static void ReadConnectionString(MigrationToolSettings settings)
{
var vdm = new VirtualDirectoryMapping(_settings.SourceDirectory, true);
var wcfm = new WebConfigurationFileMap();
wcfm.VirtualDirectories.Add("/", vdm);
var config = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/");
var connectionString = config.ConnectionStrings.ConnectionStrings["EPiServerDB"].ConnectionString;
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ConfigurationErrorsException("Cannot find EPiServer database connection");
}
settings.ConnectionString = connectionString;
}
private string[] GetModulesFromConfig(XafApplication application)
{
Configuration config;
if (application is IWinApplication)
{
config = ConfigurationManager.OpenExeConfiguration(AppDomain.CurrentDomain.SetupInformation.ApplicationBase + _moduleName);
}
else
{
var mapping = new WebConfigurationFileMap();
mapping.VirtualDirectories.Add("/Dummy", new VirtualDirectoryMapping(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, true));
config = WebConfigurationManager.OpenMappedWebConfiguration(mapping, "/Dummy");
}
return(config.AppSettings.Settings["Modules"]?.Value.Split(';'));
}
private static System.Configuration.Configuration GetConfigurationHelper(VirtualPath vpath, string physicalPath)
{
WebConfigurationFileMap fileMap = new WebConfigurationFileMap(MachineConfigPath);
VirtualPath virtualPath = vpath;
while ((virtualPath != null) && virtualPath.IsWithinAppRoot)
{
string virtualPathStringNoTrailingSlash = virtualPath.VirtualPathStringNoTrailingSlash;
if (physicalPath == null)
{
physicalPath = HostingEnvironment.MapPath(virtualPath);
}
fileMap.VirtualDirectories.Add(virtualPathStringNoTrailingSlash, new VirtualDirectoryMapping(physicalPath, IsAppRoot(virtualPath)));
virtualPath = virtualPath.Parent;
physicalPath = null;
}
return(WebConfigurationManager.OpenMappedWebConfiguration(fileMap, vpath.VirtualPathStringNoTrailingSlash, HostingEnvironment.SiteName));
}
/// <summary>
/// Gets the configuration.
/// </summary>
/// <returns></returns>
public static Configuration GetConfiguration()
{
Configuration configuration;
try
{
configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
}
catch (Exception)
{
var mapping = new VirtualDirectoryMapping(AppDomain.CurrentDomain.BaseDirectory, true);
var map = new WebConfigurationFileMap();
map.VirtualDirectories.Add("/", mapping);
configuration = WebConfigurationManager.OpenMappedWebConfiguration(map, "/", System.Web.Hosting.HostingEnvironment.ApplicationHost.GetSiteName());
}
return(configuration);
}
internal ConfigMapPath(string physicalPath, ConfigurationFileMap fileMap, bool pathsAreLocal)
{
this._pathsAreLocal = pathsAreLocal;
var configDir = Path.Combine(RuntimeEnvironment.GetRuntimeDirectory(), "Config");
this._machineConfigFilename = Path.Combine(configDir, "machine.config");
this._rootWebConfigFilename = Path.Combine(configDir, "web.config");
if (!string.IsNullOrEmpty(fileMap.MachineConfigFilename))
{
if (this._pathsAreLocal)
{
this._machineConfigFilename = Path.GetFullPath(fileMap.MachineConfigFilename);
}
else
{
this._machineConfigFilename = fileMap.MachineConfigFilename;
}
}
this._webFileMap = fileMap as WebConfigurationFileMap;
if (this._webFileMap != null)
{
this._siteName = "Default Site";
this._siteID = "1";
/*if (this._pathsAreLocal)
* {
* foreach (string str in this._webFileMap.VirtualDirectories)
* {
* this._webFileMap.VirtualDirectories[str].va;
* }
* }*/
VirtualDirectoryMapping mapping2 = this._webFileMap.VirtualDirectories[null];
if (mapping2 != null)
{
this._rootWebConfigFilename = Path.Combine(mapping2.PhysicalDirectory, mapping2.ConfigFileBaseName);
this._webFileMap.VirtualDirectories.Remove(null);
}
}
}
public void ShouldAddModifiedAt()
{
CreateSampleConfigFile();
new WebConfigUpdater("Web.config")
.OverrideAppSettingsWithEnvironmentVars();
string directory = Path.GetDirectoryName(Path.GetFullPath("Web.config"));
WebConfigurationFileMap wcfm = new WebConfigurationFileMap();
VirtualDirectoryMapping vdm = new VirtualDirectoryMapping(directory, true, "Web.config");
wcfm.VirtualDirectories.Add("/", vdm);
//WebConfigurationManager seems bugging in Mono 3.2.4
Configuration webConfig = WebConfigurationManager.OpenMappedWebConfiguration(wcfm, "/");
CollectionAssert.Contains(webConfig.AppSettings.Settings.AllKeys, "AppSettingsAutoReconfiguration_ModifiedAt");
Console.WriteLine(webConfig.AppSettings.Settings ["AppSettingsAutoReconfiguration_ModifiedAt"].Value);
}
/// <summary>Returns a collection of namespaces imported in web.config files</summary>
/// <param name="namespaces">A collection to add namespaces imported in web.config files to</param>
private void GetWebConfigNamespaces(Collection <NamespaceImport> namespaces)
{
string currentPath = this.Parent.Document.Path; // "D:\\CarolesFiles\\Documents\\Visual Studio 2010\\Projects\\OdeToFood\\OdeToFood\\Views\\Home\\";
string projectPath = this.Parent.ContainingProject.FullName; //"D:\\CarolesFiles\\Documents\\Visual Studio 2010\\Projects\\OdeToFood\\OdeToFood\\OdeToFood.csproj";
projectPath = Path.GetDirectoryName(projectPath);
var configFileMap = new WebConfigurationFileMap();
var virtualDirectories = configFileMap.VirtualDirectories;
string directoryVirtualPath = null;
while (!currentPath.Equals(projectPath, StringComparison.OrdinalIgnoreCase))
{
currentPath = Path.GetDirectoryName(currentPath); // Gets the path of the current path's parent
string relativePath = currentPath.Substring(projectPath.Length);
bool isAppRoot = currentPath.Equals(projectPath, StringComparison.OrdinalIgnoreCase);
string virtualPath = relativePath.Replace('\\', '/');
if (virtualPath.Length == 0)
{
virtualPath = "/";
}
directoryVirtualPath = directoryVirtualPath ?? virtualPath;
virtualDirectories.Add(virtualPath, new VirtualDirectoryMapping(currentPath, isAppRoot: isAppRoot));
}
var config = WebConfigurationManager.OpenMappedWebConfiguration(configFileMap, directoryVirtualPath);
// We use dynamic here because we could be dealing both with a 1.0 or a 2.0 RazorPagesSection, which
// are not type compatible.
dynamic section = config.GetSection(RazorPagesSection.SectionName);
if (section != null)
{
foreach (NamespaceInfo n in section.Namespaces)
{
Debug.WriteLine(n.Namespace);
namespaces.Add(new NamespaceImport(n.Namespace, n.Namespace));
}
}
}
// Utility to map virtual directories to physical ones.
// In the current physical directory maps
// a physical sub-directory with its virtual directory.
// A web.config file is created for the
// default and the virtual directory at the appropriate level.
// You must create a physical directory called config at the
// level where your app is running.
static WebConfigurationFileMap CreateFileMap(string rootPath)
{
WebConfigurationFileMap fileMap = new WebConfigurationFileMap();
// Get he physical directory where this app runs.
// We'll use it to map the virtual directories
// defined next.
string physDir = rootPath;
// Create a VirtualDirectoryMapping object to use
// as the root directory for the virtual directory
// named config.
// Note: you must assure that you have a physical subdirectory
// named config in the curremt physical directory where this
// application runs.
VirtualDirectoryMapping vDirMap = new VirtualDirectoryMapping(physDir, true);
// Add vDirMap to the VirtualDirectories collection
// assigning to it the virtual directory name.
//fileMap.VirtualDirectories.Add("/config", vDirMap);
// Create a VirtualDirectoryMapping object to use
// as the default directory for all the virtual
// directories.
VirtualDirectoryMapping vDirMapBase = new VirtualDirectoryMapping(physDir, true, "web.config");
// Add it to the virtual directory mapping collection.
fileMap.VirtualDirectories.Add("/", vDirMapBase);
//# if DEBUG
// // Test at debug time.
// foreach (string key in fileMap.VirtualDirectories.AllKeys)
// {
// Console.WriteLine("Virtual directory: {0} Physical path: {1}",
// fileMap.VirtualDirectories[key].VirtualDirectory,
// fileMap.VirtualDirectories[key].PhysicalDirectory);
// }
//# endif
// Return the mapping.
return(fileMap);
}
public static System.Configuration.Configuration OpenMappedWebConfiguration(WebConfigurationFileMap fileMap, string path, string site, string locationSubPath)
{
}
public static System.Configuration.Configuration OpenMappedWebConfiguration(WebConfigurationFileMap fileMap, string path)
{
}
