By utilizing breadcrumb navigation you allow your viewers to easily trace their path taken to the current location and back track if necessary.

A breadcrumb navigation usually looks something like:

Main Page > Page Design : ASP.NET Breadcrumbs with C#

Within this article you will learn how to create breadcrumb navigation using ASP.NET and C#.

In the above example we see that the viewer started on the ’Main Page’, then moved to the ‘Page Design’ section, then selected the ‘ASP.NET Breadcrumbs with C#’ page, where they currently reside. The Main Page and Page Design will be hyperlink so that you can go directly to the above sections.

The first part, ‘Main Page’ is where the user is starting; typically something like ‘Home’ or ‘Home Page’ will be used. However, we will use a variable in our code so that the user may decide what text they would like to use. The next part ‘Page Design’ is a sub-category that holds the page that the user is currently viewing, ‘ASP.NET Breadcrumbs with C#’. We know that this is the final resting spot because the ‘:’ preceding the page name indicates so. Finally, the ‘>’ is used as a separator for categories, this also is a variable, allowing for a choice of symbol.

[source: c#]

using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.ComponentModel;
using System.Text;
// We include the System.Text namespace so we can use the StringBuilder object later.
namespace BreadCrumbs
{
///
/// Summary description for ctrlBreadCrumbs.
///
public class ctrlBreadCrumbs : System.Web.UI.WebControls.WebControl
{
///
/// The 3 variables below, Separator, RootName, directoryNameSpacer can be changed to meet your needs
/// PageTitle is pulled from the CodeBehind of the page
///
public string Separator = ” > “;
public string RootName = “Home Page”;
public char directoryNameSpacer = ‘_’;
private string _PageTitle;

// Above are our variables that we can set:
// Separator is the ‘>’ symbol
// RootName is the homepage anchor text
// directoryNameSpacer is the naming scheme for my directories, for example: search_engine_optimization or website_design (notice the URL in the address bar above)

public string PageTitle
{
get
{
return _PageTitle;
}
set
{
_PageTitle = value;
}
}
///
/// Render this control to the output parameter specified.
///
///

[/source]

The HTML writer to write out to

[source: c#]
protected override void Render(HtmlTextWriter output)
{
StringBuilder sbResult = new StringBuilder();
// sbResult StringBuilder will hold the breadcrumb navigation when done

// get the url root, like www.domain.com
string strDomain = Page.Request.ServerVariables["HTTP_HOST"].ToString();
strDomain.Trim(); // Trim removes leading and trailing whitespace
sbResult.Append ( “” + RootName + “” + Separator );

// gets dir(s), like subdirectory/subsubdirectory/file.aspx
string scriptName = Page.Request.ServerVariables["SCRIPT_NAME"].ToString();
// find the last ‘/’ and Remove the text after it as it’s the file name
int lastSlash = scriptName.LastIndexOf(‘/’); // returns the # of chars. from right to /
string pathOnly = scriptName.Remove(lastSlash, (scriptName.Length – lastSlash));

// create breadcrumb HTML for the directory name(s)
// We Remove the first “/” otherwise when you split the string the first item in array is empty
pathOnly = pathOnly.Substring(1);
string[] strDirs = pathOnly.Split(‘/’);
int nNumDirs = strDirs.Length;

// URLs for breadcrumbs
string strURL = “”;
for (int i=0; i
{
strURL += “/”+strDirs[i];

// convert underscores to spaces
strDirs[i] = strDirs[i].Replace(directoryNameSpacer,’ ‘);

int counter = i+1;
if (counter != nNumDirs)
{
sbResult.Append ( “” + strDirs[i] + “” + Separator );
}
else
{
// This is the last directory so don’t tack on Separator
sbResult.Append ( “” + strDirs[i] + “” ); }
}
// write the PageTitle, pulled from the CodeBehind!
sbResult.Append ( ” : ” + this.PageTitle );

output.Write ( sbResult.ToString() );

}
}
}
[/source]

We are going to use an ASP.NET User control (.ascx) so that we may simply add this control to our pages making it easy to maintain and modify later if we should choose to. For example, if we have 100 pages and we want to modify the separator in our breadcrumb navigation from the “>” symbol to an image we will only have to modify 1 page, our .ascx page and not all 100 .aspx pages.

[source: c#]

<%@ Register TagPrefix=”bc” Namespace=”BreadCrumbs” Assembly=”BreadCrumbs” %>

protected BreadCrumbs.ctrlBreadCrumbs bc1;

private string _strHeaderText;
public string HeaderText
{
get
{
return _strHeaderText;
}
set
{
_strHeaderText = value;
}
}

private void Page_Load(object sender, System.EventArgs e)
{
// Put user code to initialize the page here
bc1.PageTitle = HeaderText;
}
[/source]

Creating Our Web Pages (.aspx). For each page (.aspx) you create for your website use a literal . This allows us to define the actual title for our page in the code behind. By defining the title of the page in the code behind we gain the benefit of only having to assign it once and have it not only be used for the title of our page, but also be used in our breadcrumb navigation.

Your code behind would look like this:

[source:c#]

public class CodeBehind_for_page: System.Web.UI.Page
{
protected System.Web.UI.WebControls.Literal lblPageTitle;
protected NameSpace.headerBreadCrumb header;

private void Page_Load(object sender, System.EventArgs e)
{
// Put user code to initialize the page here
string PageTitle = “ASP.NET Breadcrumbs with C#”;
lblPageTitle.Text = PageTitle;
header.HeaderText = PageTitle;
}
}

[/source]

We created a class for our breadcrumb navigation and used that class for an ASP.NET User control (.aspx). This allows us to simply drop the User control into each web page (.aspx) we create. Once we have our User control in our page we assign the PageTitle in the code behind and this gets used for the site.

Copyright @ Abhishek Arya 2007

An article to illustrate editing and encrypting of sections of Web.Config file programatically. It is illustrated with an ASP.NET 2.0 application, which can edit and encrypt sections of Web.Config.

.NET Classes used :

# System.Web.Security;
# System.Configuration;
# System.Web.Configuration;

Introduction

ASP.NET 1.x allowed configurations in web.config file to be read from .NET application. But there were o options to manipulate Web.Config contents in programatically. To achieve this we had to consider Web.Config file as a normal file or an xml file. .NET 2.0 fills this gap and lso provides many other useful operations to be carried out on Web.Config file; like
editing and encrypting sections of Web.Config file. This articles illustrates these functionalities ia a sample ASP.NET application.

Using the code

The classes and methods to take control of the Web.Config file span across 2 namespaces.

1. System.Configuration
2. System.Web.Configuration

Each section in the Web.Config file has a corresponding class in either of the namespace. These classes allow modification of corresponding sections. The classes for sections within the “system.web” section are found in System.Web.Configuration. Classes for other sections that are not specific to Web.Config are found in System.Configuration.

Steps to modify a section in Web.Config
1. Open Web.Config for editing using WebConfigurationManager class.
2. Using respective Configuration class, bring about the necessary changes.
3. Save changes to the physical file using Configuration class.

[source:c#]

private void UpdateConfig(string strKey, string strValue)
{
Configuration objConfig = WebConfigurationManager.OpenWebConfiguration(“~”);
AppSettingsSection objAppsettings = (AppSettingsSection)objConfig.GetSection(“appSettings”);
if (objAppsettings != null)
{
objAppsettings.Settings[strKey].Value = strValue;
objConfig.Save();
}
}

[/source]

In the above piece of code, OpenWebConfiguration() method of WebConfigurationManager class opens Web.Config file in the root directory and returns it as a Configuration object. GetSection() method of Configuration class accepts path to a specific section as argument. The path is the relative path from the root node “configuration”. You can refer to deeper nodes(sections in our context) by their names separated by ’/’. For example, to get access to the “authentication” section, provide “system.web/authentication” as the parameter to GetSection() method. It returns a generic ConfigurationSecton object, which can be typecasted to proper configuration section class. In our example we get hold of the “appSettings” section with the help of AppSettingsSection class. AppSettingsSection class instance has a Settings collection property which contains application setting from the configuration section as key-value pairs. The Settings property can be indexed using key to get the corresponding value. You can also set the value property and call the Save() method of the Configuration object to write configurations in the Configuration instance to config file.

To delete an entry in the Web.config file:
The Remove() method of Settings collection deletes an entry from the Configuration instance. Remove() method accepts key of the entry to be deleted.

Note:
Please do not forget to call the Save() method of the Configuration instance to get the changes reflected in the physical file.

[source:c#]

objAppsettings.Settings.Remove(“Location”);

[/source]

To iterate through all the key-value pairs in a configuration section, access the string array of keys via All Keys property of Settings collection.

[source:c#]

foreach (string strKey in objAppsettings.Settings.AllKeys)
{
DataRow dr = dt.NewRow();
dr["Key"] = strKey;
dr["Value"] = objConfig.AppSettings.Settings[strKey].Value;
dt.Rows.Add(dr);
}

[/source]

Encrypting sections in Web.Config file

Now comes the security issues. At times there comes the necessity for protecting sections of config file. In .NET 2.0 there are options available to encrypt sections of Web.config file programatically. The following method encrypts the “appSettings” section in Web.config file.

[source:c#]

private void EncryptAppSettings()
{
Configuration objConfig = WebConfigurationManager.OpenWebConfiguration(Request.ApplicationPath);
AppSettingsSection objAppsettings = (AppSettingsSection)objConfig.GetSection(“appSettings”);
if (!objAppsettings.SectionInformation.IsProtected)
{
objAppsettings.SectionInformation.ProtectSection(“RsaProtectedConfigurationProvider”);
objAppsettings.SectionInformation.ForceSave = true;
objConfig.Save(ConfigurationSaveMode.Modified);
}
}

[/source]

The code above opens Web.Config file for modification. It then retrieves the “appSettings” section. The ProtectSection() method of SectionInformation class marks the configuration section for protection. It accepts the name of the protection provider to be used for the encryption. The ForceSave property indicates if the specified configuration section will be saved even if it has not been modified. Finally the Save() of the Configuration object writes the configuration settings to the Web.config file. The argument to the Save() method indicates the only properties modified
need to be written to the physical file.

Decrypting sections of web.config file through code is very identical. The UnprotectSection() method of SectionInformation class removes the encryption from he configuration section.

[source:c#]

private void DecryptAppSettings()
{
Configuration objConfig = WebConfigurationManager.OpenWebConfiguration(Request.ApplicationPath);
AppSettingsSection objAppsettings = (AppSettingsSection)objConfig.GetSection(“appSettings”);
if (objAppsettings.SectionInformation.IsProtected)
{
objAppsettings.SectionInformation.UnprotectSection();
objAppsettings.SectionInformation.ForceSave = true;
objConfig.Save(ConfigurationSaveMode.Modified);
}
}

[/source]

This encrytion and decryption functionality can be applied to other sections of web.config file also. It comes in use mostly for “connectionStrings” section where usually the user name and password would be specified. This can done by creating a ConfigurationSection object. An example for “connectionStrings” section is listed below.

[source:c#]

ConfigurationSection objConfigSection = objConfig.ConnectionStrings;

[/source]

ConfigurationSection class represents a section within the configuration file. Configuration class has propertes for each configuration section. This property can be used to get respective ConfigurationSection objects. This is an alternative to the usage of GetSection() method of Configuration class.

Copyright @ Mohammed Habeeb 2007

Query notification is a feature included in Microsoft SQL Server 2005 that allows applications to be notified when data has changed. It is mainly used for applications that stores cache of data from a database and get refreshed and notified in the client application everytime the data changes in the database.

Developers in ASP.NET 2.0 are already familiar with the use the SqlCacheDependency classes in their web applications to buffer SQL Data. This article deals with the high-level implementation as provided by the SqlDependency class in System.Data.SqlClient Namespace. It provides a simple and elegant notification functionality between the windows application and SQL Server, enabling you to use a dependency to detect changes in the server. It effectively leverages the SQL Server 2005 notifications capability to the managed client applications using ADO.NET.

SQL Server 2005 allows ADO.NET Windows applications to send a command to SQL Server and request that a notification be generated if executing the same SQL command would produce result sets different from those initially retrieved. Query Notification is supported by the database’s Service Broker Event and Queueing Mechanisms.

Step-By-Step approach in implementing Query Notifications

The whole process of request-receive notification process between the client windows application and the SQL Server 2005 is done in five little steps as follows:

1) The database that is in question must be configured to enable query notification services.

For security reasons, SQL Server 2005 databases do not have Service Broker enabled by default. To enable query notifications for your database, in the SQL SERVER 2005 MAnagement Studio, Query window, run the following command:

ALTER DATABASE SET ENABLE_BROKER;

In this article, I uses the database named AdvtDB

ALTER DATABASE AdvtDB SET ENABLE_BROKER;

2) The user must have the correct client and server side permissions to request and receive notifications.

Users who execute commands requesting notification must have SUBSCRIBE QUERY NOTIFICATIONS database permission on the server.Client-side code that runs in a partial trust situation requires the SqlClientPermission.

[source:c#]
private bool EnoughPermission()
{
SqlClientPermission perm = new SqlClientPermission(System.Security.Permissions.PermissionState.Unrestricted);
try
{
perm.Demand();
return true;
}
catch (System.Exception)
{
return false;
}
}

[/source]

3) Use a SqlCommand object to execute a valid SELECT statement with an associated notification object—SqlDependency.

SqlDependency Object The query notifications API provides SqlDependency object to process notifications. When using SqlDependency, Service Broker objects, such as the notification queue, are predefined. It automatically launches a worker thread to process notifications as they are posted to the queue; it also parses the Service Broker message, exposing the information as event argument data. SqlDependency must be initialized by calling the Start method to establish a dependency to the database. This is a static method that need be called only once during application initialization for each database connection required. The Stop method should be called at application termination for each dependency connection that was made.

On Click of a button, database connection is established, SqlDependency is started to listen the notification service and a DataGridView Control is displayed with current results returned from a query executed by the command object.

[source:c#]

private void button1_Click(object sender, EventArgs e)
{

// Remove any existing dependency connection, then create a new one.
connstr = “Data Source=localhost;Integrated Security=SSPI;Initial Catalog=AdvtDB;”;
string ssql = “select * from advt “;

SqlDependency.Stop(connstr);
SqlDependency.Start(connstr);
if (connection == null)
connection = new SqlConnection(connstr);
if (command == null)
command = new SqlCommand(ssql , connection);
if (myDataSet == null)
myDataSet = new DataSet();
GetAdvtData();
}

[/source]

GetAdvtData() is a helper function that creates the command object instance, associate it with the SqlDependency object. Note that the SqlDependency object has an OnChange event notifying the client that changes has been done in the database and its eventhandler dependency_OnChange will take care of the receiving part of the notification.

[source:c#]

private void GetAdvtData()
{
myDataSet.Clear();
// Make sure the command object does not already have a notification object associated with it.
command.Notification = null;
// Create and bind the SqlDependency object to the command object.
SqlDependency dependency =new SqlDependency(command);
dependency.OnChange += new OnChangeEventHandler(dependency_OnChange);

using (SqlDataAdapter adapter = new SqlDataAdapter(command))
{
adapter.Fill(myDataSet, “Advt”);
dataGridView1.DataSource = myDataSet;
dataGridView1.DataMember = “Advt”;
}
}

[/source]

4) Provide code to process the notification when and if the data being monitored changes.

The worker thread process encapsulates the OnChange Event handler and hence, the UI changes(updating the datagrid, displaying the status message) available in the Main thread might not be accessible here. Create another delegate thread UIDelegate that does these tasks and let the
worker thread removes just the handler from the OnChange event of the SqlDependency object.

[source:c#]
delegate void UIDelegate();
private void dependency_OnChange(object sender, SqlNotificationEventArgs e)
{
UIDelegate uidel = new UIDelegate(RefreshData);
this.Invoke(uidel, null);

//Remove the handler as it is used for a single notification.
SqlDependency dependency =(SqlDependency)sender;
dependency.OnChange -= dependency_OnChange;
}
private void RefreshData()
{
// At this point, the code is executing on the UI thread, so it is safe to update the UI.

label1.Text = “Database had some changes and are applied in the Grid”;

// Reload the dataset that is bound to the grid.
GetAdvtData();
}

[/source]

5) Stop the SqlDependency Notification Services while quitting the application.

In the form_closing event, you include the code for stopping the SqlDepenency notification listener service.

[source:c#]

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
SqlDependency.Stop(connstr);
if (connection != null)
connection.Close();
}

[/source]

Following are the declarations used in this program.

[source:c#]

private const string statusMessage;
private DataSet myDataSet = null;
private SqlConnection connection = null;
private SqlCommand command = null;
private string connstr;

[/source]

Testing the application

Run the C# Windows application you have just created following the above steps. When the form shows up, Click the button and notice that your datagridview control is populated.

Now, Open the Query window of the SQL Server Management studio, and insert rows or update columns in the table concerned. When you switch back to your C# running application, you could see the changes appeared in the datagrid view.

Copyright @ Balamurali Balaji 2007