Modifying Web.config file programmatically

Introduction

ASP.NET 1.x allowed developers to modify web.config file by hands. However, there was no way to modify the configuration file programmatically. At times  this proved to be a limitation and developers used some tweaks to achieve this. Thankfully ASP.NET 2.0 has come up with a neat way of accessing (reading and writing) the web.config file via code. This article is going to demonstrate an example of how this is done.

Classes and namespaces

The System.Configuration and System.Web.Configuration namespaces provide necessary classes to manipulate web.config. For each web.config section there is corresponding class in either System.Configuration or System.Web.Configuration namespace.

You can open the web.config for modification using WebConfigurationManager class. Then you get hold of the section to be modified using Configuration class. Finally, when you are done you can save changes using Configuration class again.

For the sections that are not specific to a web application as such (<appSettings> and <connectionStrings>) the classes can be found in System.Configuration namespaces. For example, for <appSettings> section there is a class called AppSettingsSection in the System.Configuration. For the sections that are specific to a web application (<authentication>, <compilation> etc.) there are classes in the System.Web.Configuration namespace. For example, there is a class called CompilationSection that represents <compilation> section under <system.web>. These classes allow you to read and modify various properties which in turn are reflected in the corresponding section of web.config.

Example - Modifying the <appSettings> section

As an example we will demonstrate the use of above classes in reading and modifying <appSettings> section.

Create a new web site using VS.NET 2005. Add a web form to it and design it as shown in Figure 1.

Figure 1: Designing App Settings Editor

The web form consists of a DropDownlist and two TextBoxes. The AutoPostBack property of the DropDownList is set to true. When the page loads we will read the <appSettings> section and fill all the keys into the DropDownList. You can select the key in the DropDownList and its existing value will be displayed in the TextBox below. You can also add new key in the <appSettings> section by adding it in the TextBox placed beside the DropDownList. When you click on the Save button the key is either added or updated with its new value. Similarly, when you click the Delete button the selected key from the DropDownList is deleted.

Add a web.config file to the web site and key in the following markup to it:

<appSettings>
   <add key="key1" value="value1" />
   <add key="key2" value="value2" />
   <add key="key3" value="value3" />
</appSettings>

We simply added an appSettings section with three keys - key1, key2 and key3.

Now go in the code behind of the web form and import the following two namespaces:

using System.Configuration;
using System.Web.Configuration;

Add a function called FillDropDownList() that populates the DropDownList with all the keys from <appSettings> section.

private void FillDropDownList()
{
Configuration config;
config = WebConfigurationManager.OpenWebConfiguration("~");
AppSettingsSection appsettings;
appsettings = (AppSettingsSection)config.GetSection("appSettings");
DropDownList1.Items.Clear();
foreach (string key in appsettings.Settings.AllKeys)
{
DropDownList1.Items.Add(key);
}
}

Here, we called OpenWebConfiguration() static method of WebConfigurationManager class. Since we are interested to access web.config of our own application and that too residing in the root folder we pass "~" as the parameter. You can also open web.config files of other web sites and locations using various overloads of OpenWebConfiguration method. The return value of OpenWebConfiguration() method is an instance of class Configuration.

We then call GetSection() method of Configuration class to get hold of the <appSettings> section. The GetSection() methods accepts the path of the section within the configuration file. Since <appSettings> resides immediately within <configuration> root node we specified appSettings as the parameter. If you want to access, let's say, <compilation> section you would have passed system.web/compilation as the parameter to GetSection() method.

The return value of GetSection() method is of generic type ConfigurationSecton and hence we typecast it to AppSettingsSection. Then we iterate through all the keys of <appSettings> section using the Settings name value collection of AppSettingsSection class and add it to the DropDownList.

Now call the FillDropDownList() method in Page_Load event as shown below:

protected void Page_Load(object sender, EventArgs e)
{
   if (!IsPostBack)
   {
     FillDropDownList();
   }
}

Now handle SelectedIndexChanged event of the DropDownList as shown below:

protected void DropDownList1_SelectedIndexChanged
(object sender, EventArgs e)
{
Configuration config;
config = WebConfigurationManager.
OpenWebConfiguration("~");
AppSettingsSection appsettings;
appsettings = (AppSettingsSection)
config.GetSection("appSettings");
TextBox2.Text = appsettings.Settings
[DropDownList1.SelectedValue].Value;
}

Here we simply read the value of the selected key from the DropDownList using Settings collection of AppSettingsSection and assign it to the Text property of TextBox2.

Next, add the following code in the Click event of Save button.

protected void Button1_Click
(object sender, EventArgs e)
{
Configuration config;
config = WebConfigurationManager.
OpenWebConfiguration("~");
AppSettingsSection appsettings;
appsettings = (AppSettingsSection)config.
GetSection("appSettings");
if (appsettings != null)
{
if (TextBox1.Text == "")
{
appsettings.Settings
[DropDownList1.SelectedValue].Value = 
TextBox2.Text;
}
else
{
appsettings.Settings.Add
(TextBox1.Text,TextBox2.Text);
}
config.Save();
}
}

We get hold of the appSettings section as before. Then we check if the user has entered any value in the TextBox (indicating that this is a new key to be added). If the TextBox1 is empty we set the key selected in the DropDownList with the value entered in the TextBox2. Otherwise, we add a new key in the Settings collection. Finally, we call Save() method of Configuration class to persist the changes to the disk.

Add the following code to the Click event of Delete button.

protected void Button2_Click
(object sender, EventArgs e)
{
Configuration config;
config = WebConfigurationManager.
OpenWebConfiguration("~");
AppSettingsSection appsettings;
appsettings = (AppSettingsSection)config.
GetSection("appSettings");
if (appsettings != null)
{
appsettings.Settings.Remove
(DropDownList1.SelectedValue);
config.Save();
FillDropDownList();
}
}

Here we call Remove() method of the Settings collection and pass the key selected from the DropDownList. As before we call Save() method to persist the changes. We call FillDropDownList() method again so that latest keys are displayed back in the DropDownList.

Run the web form and see if modifications and deletions work as expected.

Things to note

It is important to know the impact of changing web.config file via code on the overall behavior of the application.

When you change web.config file ASP.NET senses the changes automatically and restarts your web application. This means values stored in the session and application variables are lost. If you are changing web.config often then it can affect performance of your web application because of such frequent restarts.

You must have write access to the web.config file. You may think of using Windows based security coupled with impersonation.

Summary

ASP.NET 2,0 allows a flexible way to change web.config file programmatically. Using this technique you can access various sections of the configuration file and read or write to them. However, one should use this feature with proper understanding of side-effects such as application restarts and permissions.