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 ?

real life example:

My client had an Orders table where online shop orders  were stored while his requirement was to create a graph that will show daily and monthly orders, so the question was how to group dates when order time was different? To convert it to varchar and then to remove time or to just group by day(orderDate),month(orderDate),yeaR(orderDate) ? Way too long, here where this trick came in use for. Basically what it does is gets number of days from zero day inside of datediff function and then adds this amount zero day to get smalldatetime type back. This trick works with days and month just instead of dd call mm

code:

select sum(productPrice) as productPrice,

count(productPrice) as numOfProductsSold

from Orders

group by dateadd(dd,datediff(dd,0,orderDate),0)

real life example:

My client’s community website had a sql table OnlineUsers where every logged in user was stored on login with time user logged in or moved a page last time which was an indication that user is still online. Previously a trigger to delete inactive users was a login of some other user. So each time other user logged in, he triggered delete statement on table where userLastActivityTime was more than 30 minutes ago. In some situation each minute about 20 users users logged in and at night there were almost none. So i came up with idea to create a scheduled sql task that runs each two minutes and deletes users that made no action in 30 minutes. It reduces number of requests in daytime and made night results more precise. In general it reduces amount of unwanted transactions in x times.

pictures:

[View with PicLens]

real life example :

problem i faced lately was relationship icons near each profile for community website when users had a relationships (ie. sent messages), messages were stored in “Messages” table and my requirement was to show near each user’s profile whether logged user had a relationship with them and what kind. So you could say just have a JOIN between “Users” and “Messages” sql tables but first of i had 4 kinds of relationships and second of all think what kind of optimization would it be to have even one JOIN between two tables with more than hundreds of thousands records each. This ain’t working unless you are ready to buy super servers to store databases on. You could also say create a function that checks for each returned from query user what kind of relationship logged user has with which is fine but i this way i would have many double records like UserA and UserB could have messaged each other, added to friend or blacklist.

So the idea was to create a Relationships sql table which holds User1,User2,Relationship1,Relationship2,Relationship3,Relationship4. When any Relationship column was an integer “0” for no relationship, 1 for User1’s action, 2 for User2’s action and 3 for mutual action ( both users messaged each other).

You  can say now cool, this what i should do in the first place but if you work on website optimization like i did? What if you are not the original designer?

Now what ? Problem is that there is a message record for each message sent between users so every time message was sent the sender was User1 and the receiver was User2 which created lots of records for single relationship when i needed create one field  that contains all the relationships between two users. This where for statement comes handy. First of all i created a stored procedure that had a conditional logic, checked if there is a relationship between users and then updated or inserted upon request. Now all i need is a for loop though Messages table so it will send User1 and User2 to my stored procedure, this is where cursors came to save me because otherwise i would be needed to create C# function to make the conditional logic which would be many times slower. Cursors are not advisable for real time results as well simply because they are very slow and CPU demanding compared to more elegant solutions in sql or just proper design but in off-line changes like these i could allow to have cursor for loop but again the are much faster than C# accessing the database and manipulating it.

here is the code

code :

-- setting nocount on so the query will be faster as won't return number of rows affected
set nocount on
-- declaration of two int variables which will hold current userID's
declare @userA int, @userB int
--declaration of the cursor that will loop though table in it's declaration
declare cur cursor for select fieldA,fieldB from tableA
-- opening cursor
open cur
-- get first result from table
fetch next from cur into @userA ,@userB
-- loop until there are no rows left
while @fetch_status = 0
begin
-- stored procedure with current userIDs
exec someStoredProcedure @userA ,@userB
-- get next result
fetch next from cur into @userA ,@userB
end
-- closing cursor
close cur
-- removing it from sql server memory
deallocate cur

real life example:

My client had a CostumerDeals table with large amount of records in it, each time a costumer logged in to check his deals this large table was looped though. So my idea was to create a trigger (see schedule MSSQL query task) that will move (insert into new table and then delete) costumers deals which are older than 6 month to CostumerDeals_old table so the records amount decreased in 90% which made faster responses but also made me to program a trigger for removal of older than 6 month user deal and in case user returns to get his deal records back. It was time consuming but worth it.

code :

use dbName
insert into tableA (colAA,colAB,colAC.....)
select colBA,colBB,colBC.... from tableB where dateadd(mm,6,dealDate)<getdate()