DotnetTricks: 2013

Tuesday, November 12, 2013

Performance Tuning Techniques for your web page

Some basic performance tuning techniques are shared below.

Minimize HTTP Requests:

Most of this time is tied up in downloading all the components in the page: images, style sheets, scripts, Flash, etc. Reducing the number of components in turn reduces the number of HTTP requests required to render the page. This is the key to faster pages.

To reduce the number HTTP requests, we can combine the scripts into a single script page and refer that script in the page.

Loading the scripts in parallel:

What we usually do is include script files as static links in head tag as shown below.

<head>

</head>

What browsers usually do is download them serially one after the other. The browsers like IE or Firefox will wait for the first script to get downloaded before it starts downloading second one.

We can make them to download in parallel by the below code.

document.writeln("<script src='Scripts/JQueryUI/jquery-1.9.1.js ?version=1.0

' type='text/javascript'><" +

"/script>");

document.writeln("<script src='Scripts/JQueryUI/jquery-ui-1.10.1.js ?version=1.0

' type='text/javascript'><" +

"/script>");

</script>

Avoiding the Cache Problem:

What most of the browsers do is that for the first time they download scripts to webpage but after that they take the script from the browser cache.so sometimes even if we make changes in the script and the style sheet ,that is not getting downloaded and changes are not reflecting.

We can force the browser to download the latest version of script and style sheet by versioning them.

document.writeln("<script src='Scripts/JQueryUI/jquery-1.9.1.js ?version=1.0

' type='text/javascript'><" +

"/script>");

document.writeln("<script src='Scripts/JQueryUI/jquery-ui-1.10.1.js ?version=1.0

' type='text/javascript'><" +

"/script>");

</script>

We have to increment the version number if we make changes to that script or style sheet.

document.writeln("<script src='Scripts/JQueryUI/jquery-1.9.1.js ?version=1.1

' type='text/javascript'><" +

"/script>");

document.writeln("<script src='Scripts/JQueryUI/jquery-ui-1.10.1.js ?version=1.1

' type='text/javascript'><" +

"/script>");

</script>

Bundling and Minification:

Bundling and Minification is the new feature included ASP.NET 4.5 to improve request load time.

To use Bundling and Minifcation, we have to add reference to System.Web.Optimization dll.

public class BundleConfig

{

// For more information on Bundling, visit http://go.microsoft.com/fwlink/?LinkId=254725

public static void RegisterBundles(BundleCollection bundles)

{

bundles.Add(new ScriptBundle("~/bundles/jquery").Include(

"~/Scripts/jquery-{version}.js"));

bundles.Add(new ScriptBundle("~/bundles/jquery").Include(

"~/Scripts/jquery-1.7.min.js"));

bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(

"~/Scripts/jquery-ui-{version}.js"));

bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(

"~/Scripts/jquery.unobtrusive*",

"~/Scripts/jquery.validate*"));

}

The bundled scripts can be rendered by the following code in html page.

@System.Web.Optimization.Scripts.Render("~/bundles/modernizr")

@System.Web.Optimization.Scripts.Render("~/bundles/jquery")

SQL Server Parameter Sniffing:

Parameter sniffing allows you to reduce the time taken to execute the stored procedure considerably.

This permits individual plans recompilation instead of compiling entire execution plan for single store procedure. You could find below some workaround when you are affecting by a performance issue.

Using dummy variables that are not directly displayed on parameters also ensure execution plan stability without need to add recompile hint.

create procedure SearchProducts

@Keyword varchar(100)

Declare @Keyworddummy as varchar(100)

Set @Keyworddummy = @Keyword

select ProductID,ProductName from Products where Keyword like @Keyworddummy

end

Here the parameter @Keyword is assigned to @ Keyworddummy is which is used inside the stored procedure. Like this you can do for all the parameters that are used inside the stored procedure.

Always use the column name in the select list. Avoid using * in select.

This helps you to reduce the execution time considerably and get results faster.

Monday, February 25, 2013

Object Oriented JavaScript

Some basic concepts in Object oriented JavaScript’s are discussed below

We have a button that calls a client side function GetData() on its click.

function GetData() {

testBL.getTestData();

//calling function in testBLL.js

//with object testBL and function getTestData()

}

</script>

Now we will have to create testBLL.js

In this we can create the methods and expose those methods

Code in testBLL.js:

var testBL = new function () {

ObjectOreientedScripttest = function () {

//you can write your function code here

getTestDataByDate = function () {

//you can write your function code here

}

return {

testForObjectOreientedScript:ObjectOreientedScripttest ,

getTestData: getTestDataByDate
}

} ();

This return statement is mandatory to expose those methods.

For eg:

Inside the return statement we have the below statements

getTestData: getTestDataByDate

getTestDataByDate is the function we have created in the testBLL.js and second one getTestData is the name that we get when we are calling the method.

I.e. testBL.getTestData();

testBL is the variable name that we used for testBLL.js functions(refer first line testBLL.js)

Friday, January 11, 2013

Passing Table-valued Parameter to Stored procedure

Table-Valued Parameters:

Table valued parameter provide the developer an easy way to work with Multiple rows and data. Table-Valued parameters were introduced in Sql Server 2008

Syntax:

create type TypeName AS TABLE(

column1 type,

column2 type...

)

Eg: create type EmployeeDetails AS TABLE(

RowID int,

EmployeeName varchar(25),

EmployeeTitle varchar(30),

EmployeeAge int

)

In the above eg,

We are creating a table valued type for EmployeeDetails,this table valued type replicate the same of a Sql Table.

Manipulation on Table Valued Type:

Table valued parameters are same as Sql Table.

You can insert into table valued Type as same like how you insert value to a table.

Declare @EmployeeDt as EmployeeDetails

insert into @EmployeeDt values(1,'George','Manager',24)

insert into @EmployeeDt values(2,'Rahul','Tester',38)

You can select the entire data from that table-valued type by

a single select statement.

select * from @EmployeeDt

Passing Table-Valued type to StoredProcedure:

create procedure SaveEmployeeDetails

@EmployeeDt as EmployeeDetails Readonly

Begin

--selecting from table valued parameter and inserting into table --in a single strech

insert into Tbl_Employee(ID,EmployeeName ,EmployeeTitle,EmployeeAge)

select RowID,EmployeeName ,EmployeeTitle,EmployeeAge

from @EmployeeDt

End

C# Code:

SqlDatabase sqlConn;

DbCommand dbcmd;

SqlConn = new SqlDatabase ("your Connection string here");

dbcmd = sqlConn.GetStoredProcCommand(SaveEmployeeDetails);

dbcmd.CommandType = CommandType.StoredProcedure;

sqlConn.AddInParameter(dbcmd, "@EmployeeDt", SqlDbType.Structured, dt);

sqlConn.ExecuteNonQuery (dbcmd);