Storing the settings of your ASP.NET application in the Global.asax file is the easiest way. This solution is based on using the Application_Start method and global property Application.

The Application property of HttpContext class returns HttpApplicationState object for the current HTTP request. HttpApplicationState object allows sharing of global parameters between multiple sessions and requests with you ASP.NET application.

A single instance of an HttpApplicationState class is created the first time a client requests any URL resource from within a particular ASP.NET application virtual directory. A separate single instance is created for each ASP.NET application on a Web server. A reference to each instance is then exposed via the intrinsic HttpContext.Application object.

Method Application_Start occurs as the first event in the HTTP pipeline chain of execution when ASP.NET responds to a request.

 

Review the following example:

Global.asax.cs

protected void Application_Start(Object sender, EventArgs e)
{
Application["DbUser"]="dbUser";
Application["DbUserPass"]="myPass";
Application["DbName"]="coolDB";
Application["DbServer"]="my.office.db.server";

string myConnString = "Data Source=" +
Application["DbServer"] + ";Initial Catalog=" +
Application["DbName"] + ";User ID=" +
Application["DbUser"] + ";Password=" +
Application["DbUserPass"];
Application["ConnString"] = myConnString;
} 

Thus when your web application starts the Application object will contain the values of your parameters and you can access them on page within your application.

SomePage.asax.cs

private void Page_Load(object sender, System.EventArgs e)
{
SqlConnection myCnn;
SqlCommand myCmd;
SqlDataReader myReader;
myCnn = new SqlConnection((string)Application["ConnString"]);
myCmd = new SqlCommand("select * from countries", myCnn);
myCnn.Open();
myReader = myCmd.ExecuteReader();
// :
// Do something
// :
myCnn.Close();
} 

Let's consider the advantages and disadvantages of using Global.asax as storage for web application parameters.

Advantages:

1. Simplicity of realization
2. You can store the critical parameters, which you don't want to be changed without your confirmation (Developer Name, License Information). The changing of any parameter within Global.asax file requires recompilation of whole application. So it will be impossible to do without an access to source code

Disadvantages:

1. To change the value of any parameter it is required to recompile whole application. Therefore this method is not good for parameters, which have to be changed frequently.
2. Uploading of recompiled version will cause restart of whole application.

The more flexible variant of the storing web application settings is the using of Web.config file.

Configuration information for ASP.NET resources is contained in a collection of configuration files, each named Web.config. Each configuration file contains a nested hierarchy of XML tags and subtags with attributes that specify the configuration settings. Because the tags must be well-formed XML, the tags, subtags, and attributes are case-sensitive. Tag names and attribute names are camel-cased, which means that the first character of a tag name is lowercase and the first letter of any subsequent concatenated words is uppercase. Attribute values are Pascal-case, which means that the first character is uppercase and the first letter of any subsequent concatenated words is uppercase. Exceptions are true and false, which are always lowercase.

All configuration information resides between the <configuration> and </configuration> root XML tags.

There is a special <appSettings> Element in Web.config, which can be used for storing custom application settings. This is a predefined configuration section provided by the .NET Framework.

The <appSettings> element stores custom application configuration information such as database connection strings, file paths, XML Web service URLs, or any information stored in an application's .ini file. The key/value pairs specified in the <appSettings> element can be accessed in code using the System.Configuration.ConfigurationSettings or System.Configuration.AppSettingsReader classes.

Review the following example:

Thus we can retrieve the values of our parameters by using the static methods of myConfigurator class and use these parameters in all places of our application.

Let's consider the advantages and disadvantages of using Web.config as a storage for web application parameters.

Advantages:

1. Settings can be operatively changed
2. No need to recompile whole application

Disadvantages:

1. After changing of settings application restart occurs
2. Additional system resources for file-based operations
3. Anyone, who has access to Web.config file, can change settings

The following method is based on storing application settings in database.
This method is most flexible and independent from .NET infrastructure, however it requires additional system resources for the performing of database operations.

Review the following example:

An of course let's consider the advantages and disadvantages of using database as a storage for web application parameters.

Advantages:

1. Centralized storage of all application settings
2. Settings can be operatively changed
3. No need in recompilation of whole application
4. Application restart doesn't occur after the changing of settings

Disadvantages:

1. Database engine is required
2. Additional system resources for database operations
3. General reliability of application decreases
4. Anyone, who has an access to database, can change application settings

Thus after review of all these methods we can see that you may need to use each of these methods in your application and real choice will depend on the specific of your application.

The following table will help you to choose method, which will most appropriate for your certain ASP.NET application.