part I — setting up database

Create a database with name ErrorLog inside of it create a table in database called Errors with following fields errorID, userID, userIP, errorPage, errorName, errorStack, errorDate and isRead.

CREATE TABLE [dbo].[Errors](
[errorID] [int] IDENTITY(1,1) NOT NULL,
[userID] [int] NOT NULL,
[userIP] [varchar](14) NOT NULL,
[errorPage] [nvarchar](200) NOT NULL,
[errorName] [nvarchar](100) NOT NULL,
[errorStack] [nvarchar](max) NOT NULL,
[errorDate] [smalldatetime] NOT NULL,
[isRead] [bit] NOT NULL,
CONSTRAINT [PK_Errors] PRIMARY KEY CLUSTERED
(
[errorID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

userID will be stored in case you have user logged in ( or any other tracking parameter ie. user Guid), otherwise you can save zero value. Ability to know what user had an error can help you to debug the application. userIP field useful to know whether it is the same user accessed resource with error in case there was no userID provided. errorPage is useful because sometimes there is no indication in Exception’s stack where an error appeared so saving it could be a good idea also in case you have one error logging system for multiple websites this way you will save time understanding where it was or to review an error log at any website. errorName is a short name of the exception that mostly not descriptive enough to debug but useful for short indication or error category needs. errorStack field will be used to store everything from Exception.ToString(). errorDate obviously for sorting and timing issues and isRead is useful in cases when you don’t delete errors but just hide them from viewing.

Next lets write a stored procedure “LogError” which will insert an error to database, code is quite straightforward.

CREATE PROCEDURE dbo.LogError
@userID int,
@userIP VarChar(14),
@errorPage NVarChar(200),
@errorName NVarChar(100),
@errorStack NVarChar(max)
AS
BEGIN
SET NOCOUNT ON;
INSERT INTO Errors VALUES (@userID,@userIP,@errorPage,@errorName,@errorStack,getdate(),0)
END
GO

part II — the code

We got two options “lazy way” and the “proper way”. The “lazy way” is to capture an error as it appears from global.asax Application_Error() method which i will show you in a few but it is important to understand that the “lazy way” won’t give you much as flexibility as “proper” one simply because you will just log some of errors without the ability to inform user of what really happened. Catching an error from global.asax is a global method which will act the same for any kind of error from any kind of page while “proper way” will allow you to have conditional logic so for x error application will redirect z page and y error will redirect somewhere else and show user friend message  (ie. if not logged in user tries to get to page that requires userID stored in session or cookie you would like him to be redirected to login page, to show him user friendly message and then to log an error which could be caused by wrong account confirmation mail you have sent SO IT IS IMPORTANT TO LOG ANY ACTION). This way you will know for sure where, why and how.

The “lazy method”

Code pretty much speaks for itself but here some explanation. First we get an Exception from Server.GetLastError() object then we connect to database, with “LogError” stored procedure

*** “Lazy method” suitable for those who already have an online application when architectural changes in its design will create needless bugs. Even though  “proper method” has much wider flexibility than just logging errors, so next time you start another project consider using the proper one but to use it on live application is not such a good idea.

Add this piece of code to Application_Error() method of global.asax.

Exception currentError = Server.GetLastError().GetBaseException();
using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["Errors"].ConnectionString))
{
cn.Open();
SqlCommand com = new SqlCommand("InsertError",cn);
com.CommandType = CommandType.StoredProcedure;
com.Parameters.Add("@userID", SqlDbType.Int).Value = Users.getUserID();
com.Parameters.Add("@userIP", SqlDbType.VarChar,14).Value = Users.getUserIP();
com.Parameters.Add("@errorPage", SqlDbType.NVarChar,200).Value = Request.Url.ToString();
com.Parameters.Add("@errorName", SqlDbType.NVarChar,100).Value = error.Name;
com.Parameters.Add("@errorStack", SqlDbType.NVarChar).Value = error.ToString();
try
{
com.ExecuteNonQuery();
Server.ClearError();
Response.Redirect("~/errorpage.aspx");
}
catch (Exception)
{
}
}

This is not a good idea to use empty catch block but we have no choice and nowhere to log this error, think of situation when your application database in one place and ErrorLog on another, by having try and catch block in there we protect user from being thrown from application when ErrorLog database will fail. So we won’t track an error but user will continue to browse our application.

The “proper method”

Lets create a class inside our App_Code folder caller Errors. Add a method in it caller logError. This method it wrapped by try and catch block so we will avoid Exception in case we could not be able to establish connection to Errors database or any other connection error like transaction deadlock. Thanks to Shuaib Rameh for pointing out this mistake.

try {
public static void logError(Exception ex)
{
using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["Errors"].ConnectionString))
{
SqlCommand com = new SqlCommand("LogError", cn);
com.CommandType = CommandType.StoredProcedure;
com.Parameters.Add("@userID", SqlDbType.Int).Value = Users.getUserID();
com.Parameters.Add("@userIP", SqlDbType.VarChar,14).Value = Users.getUserIP();
com.Parameters.Add("@errorPage", SqlDbType.NVarChar,200).Value = Request.Url.ToString();
com.Parameters.Add("@errorName", SqlDbType.NVarChar,100).Value = ex.Name;
com.Parameters.Add("@errorStack", SqlDbType.NVarChar).Value = ex.ToString();
com.ExecuteNonQuery();
}
}
}
catch(Exception)
{
}

Method is similar to one we added to Application_Error handler inside of global.asax with with difference we pass Exception as parameter and use its values to track an error. Now lets see how to use this method and what its flexibility will allow us to do.

public static bool isUserEmailExists(string userEmail)
{
bool isEmailExists = false;
try
{
using (SqlConnection cn = DB.connectMainapplicationDataBase())
{
SqlCommand com = new SqlCommand("IsUserEmailExists", cn);
com.CommandType = CommandType.StoredProcedure;
com.Parameters.Add("@userEmail", SqlDbType.VarChar, 50).Value = userEmail;
using (SqlDataReader reader = com.ExecuteReader())
{
if (reader.HasRows)
{
isEmailExists = true;
}
}
}
}
catch (Exception ex)
{
Errors.logError(ex);
}
return isEmailExists;
}

This a sample method in which we check whether user’s email exists in our database ie. for password recovery needs or registration. Connection is wrapped up with try-catch block and on Exception we track it down with a method we create inside of Errors class. We can redirect or do what ever we want but error will be logged. Connection here is made with using block for more information about it read  HOWTO: Properly connect to MSSQL database .

What will you gain from using this technique ?

1. Organized in one place connection strings will prevent you from searching and replacing every time you change connection string or its name.
2. You will always have a connection closed and disposed from memory even if there was an error which prevented you from getting to the line where Sqlconnection is closed and disposed from memory.

Step one — Keep all connection string at one place

Instead of hard coding every single place you connect to database you can set connection string value inside of web.config or a class. There is no rule where set connection string better in a class or web.config but any ASP.NET developer will first look at ConnectionStrings section of web.config so it would be better to keep connection strings where they belong to.

<connectionStrings>
<add name="Dismark" connectionString="Data Source=.\sqlexpress;Initial Catalog=Dismark;Integrated Security=True;Pooling=False" providerName="Sytem.Data.SqlClient"/>
<add name="Support" connectionString="Data Source=.\sqlexpress;Initial Catalog=Support;Integrated Security=True;Pooling=False" providerName="Sytem.Data.SqlClient"/>
</connectionStrings>

As you can see there are two database connection strings, it is important to name databases and give  connection string names according to what they represent. “Dismark” is an application name so i name the database and connection string the same name so in two month i won’t be needed to guess what “ConnectionString1” means. “Support” is a centralized database for costumer ticket support system because the client has few applications while it is much easier to work with centralized support ticket system rather have one per application. So each time you create an application for yourself or for a client ask yourself what whether are gonna be other applications or not because you can create external centralized Support, ErrorReports and Billing databases.

Step two — Make connections easier to use by having a function to retrieve already opened SqlConnection.

This step reduces amount of code you need to write each time you connect to database with your code. For example we will create a class inside of a App_Code folder named DB which will handle all our connections.

This is how your old code could look like

using System;
using System.Configuration;
using System.Data.SqlClient;

public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["Dismark"].ConnectionString);
cn.Open();
// code goes here
cn.Close();
cn.Dispose();
}
}

Instead lets create a DB class with two functions, each function connects to specific database, opens a connection and returns to the caller.This way we will write less code each time we connect to database, it will be easier to change if for some reason we will change a database moved to another server or we will have to change connection string name.

using System;
using System.Configuration;
using System.Data.SqlClient;

public class DB
{
public static SqlConnection connectToDismark()
{
SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["Dismark"].ConnectionString);
cn.Open();
return cn;
}
public static SqlConnection connectToSupport()
{
SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["Support"].ConnectionString);
cn.Open();
return cn;
}
}

This is a call to these functions from page where you connect to a database. As you can see there are less code to write and we don’t have to remember database’s exact name as Visual Studio’s intellisense helps us when we type DB class name.

SqlConnection cn2 = DB.connectToDismark();
// code goes here
cn2.Close();
cn2.Dispose();

Step 3 — Encapsulation of connection within using block

As you see there are two methods remain, connection.Close() and connection.Dispose(). One obviously closes the connection to database and other one disposes it from memory. We need to keep in mind that sometimes we won’t reach those lines of code because of error of some kind (ie. bad input from user which cause an error to SqlCommand object). Which means connection will remain open until Sql Server closes it. Not good practice as server may have limit or still use resources to keep the connection alive, instead of that we can encapsulate connection within using block which will automatically close() and dispose() connection when we leave its scope. Lets see how its done.

using (SqlConnection cn3 = DB.connectToDismark())
{
// code goes here
}

Sqlconnection class inherits from IDisposable interface which allows to use it within using block, same goes for SqlDataReader class.

Much faster and secure isn’t it ?

It took me few minutes to configure the handler to work, it is easy to use and well documented. So i advice you to read Omar’s post before continuing with modifications.

What the problem with Omar’s http handler ?

1. needless number of paremeters which are passed to handler, instead of having 1 parameter ie. css or js , we got 3 parameters. Why to have file type and content type together when js extension clearly means “javascript/text” content type.
2. generated by handler output is cached which means old version will be used anytime you access the page which makes imposible to use handler during developement process when we constantly modify JS and CSS files. By default there is a parameter in query string call to handler “v” which stands for version but each change you make on files you will need to update the version number so there won’t be caching.
3. each JS or CSS file must be defined in web.config which goes against my dynamic thinking

if you find these as faults in usability like i do continue reading further …

How do we fix those issues ?

First of lets get rid of parameters and just pass one that stands for file type (ie. css or js), second of all lets define folder within the application where all js and css files will be stored so we can loop though folder and dynamically get all files at once without defining each new file and last let’s define global parameter which tells handler whether it is production, development server or just a cache refresh to update website so we won’t directly deal with versioning.

I could rewrite the handler to work as i want it to but Omar did a great job with handler and all credit to him, while i don’t want to create “yet another HttpHandler” to combine css/js files.. My idea was to hack HttpCombiner as fast as i could so i could get to work with it without dealing with it’s design.

Implementation

Step I — web.config

let’s create two folders inside of our assets folder css and js, because handler already loads css you need to move all css files from your App_Theme/ThemeName folder to Assets/Css one and Js files just keep inside Assets/Js.

important note, from now on your CSS and JS files are virtually located on the root (where you place the HttpCombiner.ashx) and not inside real Assets/Foldername folder.

Once we have two folders and we understood where files gonna reside and where their virtual location will be, let’s tweak web.config file to work with new settings.

old code

</appSettings>
<appSettings>
<add key="Set_Css" value="~/App_Themes/Default/Css1.css,~/App_Themes/Default/Css2.css"/>
<add key="Set_Javascript" value="~/Javascripts/Js1.js,~/Javascripts/Js2.js,http://ajax.googleapis.com/ajax/libs/jquery/1.2.6/jquery.min.js"/>
</appSettings>

new code

<appSettings>
<add key="css" value="~/assets/css/"/>
<add key="js" value="~/assets/js/"/>
<add key="refreshCombiner" value="true"/>
</appSettings>

Step II — change of urls layout for handler calls

old urls

<link type="text/css"  rel="Stylesheet" href="HttpCombiner.ashx?s=Set_Css&amp;t=text/css&amp;v=1" />
<script type="text/javascript"  src="HttpCombiner.ashx?s=Set_Javascript&amp;t=type/javascript&amp;v=2" ></script>

new urls

<link type="text/css"  rel="stylesheet" href="HttpCombiner.ashx?t=css" />
<script type="text/javascript"  src="HttpCombiner.ashx?t=js" ></script>

Step III — modification of HttpCombiner.ashx

old code — lines 22–24

string setName = request["s"] ?? string.Empty;
string contentType = request["t"] ?? string.Empty;
string version = request["v"] ?? string.Empty;

new code

string setName = request["t"] ?? string.Empty;
string contentType = (setName == "js") ? "text/javascript" : "text/css";

string version = "1";
if (bool.Parse(ConfigurationManager.AppSettings["refreshCombiner"]))
{
version = new Random().Next(1, 999999).ToString();
}

old code — lines 47–56

string setDefinition =
System.Configuration.ConfigurationManager.AppSettings[setName] ?? "";
string[] fileNames = setDefinition.Split(new char[] { ',' },
StringSplitOptions.RemoveEmptyEntries);

foreach (string fileName in fileNames)
{
byte[] fileBytes = this.GetFileBytes(context, fileName.Trim(), encoding);
writer.Write(fileBytes, 0, fileBytes.Length);
}

new code

string filesPath = ConfigurationManager.AppSettings[setName];
string[] fileEntries = Directory.GetFiles(HttpContext.Current.Server.MapPath(filesPath));
foreach (string fileName in fileEntries)
{
byte[] fileBytes = this.GetFileBytes(context, filesPath + fileName.Trim().Remove(0, fileName.LastIndexOf("\\")), encoding);
writer.Write(fileBytes, 0, fileBytes.Length);
}

Hope you enjoyed it !!!

real life example:

I had to work on a project large part of which was written in VB, i do understand VB but i feel much more comfortable with C#.  I could use great tool by Developer Fusion, a .NET Code Converter but it was much easier to keep the old code and just have new one written in my native language.  This way i could utilize already written code inVB.

Important note, if you using VB in multi language project please write your functions as strict as possible to avoid possible compliation issues while use a combination of functions from both App_Code dirs.

code:

Create two new folders inside of App_Code folder, CS for C# code and VB obviously for VB code.  Folder names are not important as used only as identifiers for web.config attributes in code below.

<compilation>

<codeSubDirectories>

<add directoryName="CS" />

<add directoryName="VB" />

</codeSubDirectories>

</compilation>

real life example:

There was a website that used userID stored in the session in order to retrieve information about logged user. All fine because most of the time access to session object comes from within page life cycle ( ie.Page_Load) itself but it has certain complication when it comes to using functions whether these are on the same page but outside of page life cycle scope or inside of App_Code directory.

Why would i access session outside of the page’s life cycle ? Simply because anytime website requests an  userID i need to check session for null in case user lost session or never logged in. Another reason could be architectural change in the application that won’t use userID stored in the session but in object of some kind. So much more elegant solution will be to use external function that does all the job for me. Gets an userID in case there is one and if not gets n0ne can be used in conditional logic for example to redirect an user to login page.

So i’ve created a private function to get an userID and if redirectToLogin variable is TRUE then it redirects. Second private functions retrieves the real userID by accessing current context HttpContext.Current. Same way you can access anything from your page life cycle’s context ( ie.Request and Response) which i use in redirection redirectToLoginPage method. Most important is to understand that this kind of programming gives you flexibility in the future (ie. if you change your login page name or will start storing whole user details in session as User object, this way you will just need to change one function that will access User object stored in session rather searching and modifying every place userID session variable was stored.)

code:

public static int getUserID(bool redirectToLogin)
{
int userID = getUserID();
if (redirectToLogin && userID == 0)
{
redirectToLoginPage();
}
return userID;
}

private static int getUserID()
{
int userID = 0;
if (HttpContext.Current.Session["userID"] != null)
{
userID = Convert.ToInt32(HttpContext.Current.Session["userID"]);
}
return userID;
}

private static void redirectToLoginPage()
{
HttpContext.Current.Response.Redirect("~/login.aspx");
}