Whether you are building an entry-level application or an enterprise level application with N-Tier architecture, you will always think about performance. Why is performance so critical? Answer is simple – Everybody wants a fast application. As the generations of computers have evolved, we have seen a drastic change and improvements in processing speed and overall performance. I recall my first computer having 256 MB RAM. Yes. I just had a quarter of a gig RAM and it was a decent computer. Now my current machine has 16 GB RAM which is sixty four times bigger than my first computer. Moreover, if we compare the processor – it had a single core and multithreaded (Hyper threading is what they used to call it) and now I am having a quad core (four core) processor. Better machines allow us to run the applications in faster way. However, the application developer also has to take care about the machines, which are not as quite fast as the one he / she has.

        If we think about the application performance, then the way we have to think about the way the application is developed. Developing applications is easy now days where we are having tools, which reduce the time it is required for developing apps. Developing the app requires less time however developing an optimised app is something that requires a Zen of software development and experience. Performance for me is a sum of good code + best practices. The definition of good code can differ from developer to developer and I do not intend to start a war over this. Personally, I define a good code, which reads in a flow and does not cough out performance instead, it requires less lines of code and performs well.

StringBuilder vs String concatenation

        Sometimes there is more than one way to code the same thing. For example in C#, you can concatenate the two strings using a '+' operator and you can use StringBuilder class. Experienced developers must be aware of StringBuilder class. For the folks who are not aware, it is a class, which helps us concatenate multiple strings. Now you must be saying why we need a separate class to perform something, which we can do with a plus operator. However, there is twist. If you have to concatenate many strings together, it is best to go for StringBuilder. If you have few strings to concatenate, + operator is still a good choice. E.g. you get two strings from two different methods and you want to concatenate them, you definitely should choose the '+' operator because it will cause additional overhead if you go for the StringBuilder way. You should be aware and know exactly when to use concatenation and when for StringBuilder. String objects in .NET are immutable which means that each time you append, modify a string, a new instance is created for it. StringBuilder on counterpart provides a mutable way to modify, append strings. StringBuilder has a buffer which is allocated as per need. It has a Capacity property which is the available capacity of the object to hold the data. This buffer is increased as soon as the capacity is exhausted and more data is added to it. StringBuilder provides some handy methods like:

• Append – This appends the data to the current buffer.
• AppendFormat – This is something similar to String.Format hower in this case it appends the format.
• AppendLine – This appends the data and adds a Environment.NewLine at the end.
• ToString – Most important method of all. Whenever you want a single string out of the buffer, you have to call this method.

Query over IQueryable vs Query over IEnumerable

        For the folks who use LINQ for their database operations must be aware of the way we can query over a database context. The context exposes an object, which implements IQueryable interface. Now what is the significance of IQueryable you may ask? Let me answer your question. MSDN states “(IQueryable) provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified.” OK do not worry if that line did not impress you much. In simple words, the types that implement IQueryable interface have the definition of how they want to execute the expression tree (Expression trees represent code in a tree-like data structure, where each node is an expression, for example, a method call or a binary operation such as x < y.) which means that if you are querying it against the database with following code:

var employeeToFetch = context.Employees.FirstOrDefault(emp=> emp.ID == 2);

This will send query to database like (this is just for illustration purpose actual query may vary):

SELECT TOP(1) ID, Name FROM Employees WHERE ID = 2

As you can see that it is generating the query exactly what you want.

Now just for fun let us do something disastrous for your app. I am changing the statement to something like:

var employeeToFetch = context.Employees.ToList().FirstOrDefault(emp=> emp.ID == 2);

Can you guess what query will be sent to database? Umm I guess you have the hint from the “disastrous” word – it will fetch all the records. Yes. You are correct. It will fetch all the records from employees table and convert them to objects and then store it memory and then it will loop over all records to check which matches the condition (having ID equals 2) in linear way (one row at a time). Now if you compare that with the first query, then you will come to know that the first query performed better because it asked database engine to give you a single record that matches the condition. Just by adding the ToList method, the context will fetch all the records first. In short, if you want to query, query it over a Queryable instead of Enumerable wherever possible to get good performance.

IDisposable Interface

        Many of you must be aware of the IDisposable interface. It has a simple method Dispose. The Stream and Connection classes in .NET are perfect example of IDisposable objects. The Dispose method typically contains the logic to clear all unmanaged resources after their use. When we call the dispose method, the connection is closed if it is a Connection object, the stream is closed if it is a Stream object and so on. It frees up the resources and helps us regain the memory we have allocated for that operation.

Implementing IDisposable on your custom class will help you use the syntactic sugar using statement. For those who do not know, we can use using statement for adding a reference to the namespace as well as for a block of code, which implements IDisposable interface. This enables us to skip calling the Dispose method as compiler will call the method for you. For example:

using(IDisposableResource resource = new IDisposableResource())

{

                               //Do some operations here.

}

This will get compiled to something like:

IDisposableResource resource = new IDisposableResource();

try

{

                               //Do some operations here.

}

Finally

                          {

                               if(resource !=null)

{

                                      resource.Dispose();

                         }

}

As you can see, compiler generated a lot of code for you. You do not have to check for null or call dispose manually.

Using NGEN (Native image GENerator)

       .NET assemblies are compiled into intermediate language, which is then converted into native OS and processor specific code in JIT phase. If you NGEN any .NET assembly, the code is converted to native OS code and is stored on disk. The next time assembly is referred to, the native version of the assembly will be loaded thereby removing the JIT step in between. I have experienced a good improvement in my application where NGEN improved the performance by more than 300%. Yes. That is possible using NGEN. However, I suggest that you should try this with your assembly and check the performance improvements. Some assemblies turn slower (for the reasons I do not know) when we perform NGEN on them.

Stored procedure vs LINQ query

        If you have worked with stored procedures, you must be aware that stored procedure performs well if we compare that with normal textual queries. Similarly for example let us say that you have an operation which returns the top 5 salaried employees, you will write something like this with LINQ query:

var employeesToFetch = context.Employees.OrderBy(emp=> emp.Salary).Take(5);

If we compare the performance of this, it is certain that the stored procedure will perform better because the fact that stored procedures have execution flow already calculated..

In addition, most important of all is that you can call stored procedure using Entity Framework. When you generate the .edmx file, you have an option to add stored procedure too. Calling stored procedure from EF is like calling a method with that name. For example, the above stored procedure has name "TopFiveEmployeesBySalary" will be called from EF like this:

var employeesToFetch = context.TopFiveEmployeesBySalary();

Easy isn’t it?

Optimise “if” conditions

        There can hardly be any developer who has not written an if statement in his / her life. Writing an efficient if statement means to add the first condition that has a fair chance of being true. Doing this will help the code to look for the next condition only if the first statement is true. This can, to some extent improve the performance of your application.

Minimize boxing

        If you convert a value type to a reference type, it is going to cost you some performance hit. Boxing involves allocating heap memory for your value type. Assigning it to the memory slot and keeping a reference for it. Each reference type involves using eight bytes of header information. Therefore, for an int variable, if you box it, it will cost you the size of 32 bits (4 bytes) + 8 bytes = 12 bytes per int.

Prefer value types wherever possible.

        As you know now that when you box something, you have allocated additional 8 bytes of data. This is true even if you declare a class with two integers. Each object will need at least additional 8 bytes of data for keeping the reference of it. So let us say that if you want to store two integer variables in a class, consider using a struct instead. In that way, the type will be value type and it will require less memory compared to a reference type (class).

Try to use the native .NET API vs PInvoke (Interop code)

According to MSDN, it takes around 10 to 30 x86 instructions per call of PInvoke. Consider using .NET framework built in functions for it. PInvoke.NET is a good site where it lists the way we can call the native function and also provides framework sample if the operation is present in .NET framework itself.

For example if we want to extract the icon from an executable we can write the following interop code:

[DllImport("shell32.dll")]

static extern IntPtr ExtractIcon(IntPtr hInst, string lpszExeFileName, int nIconIndex);

string fileName = @"C:\WINDOWS\system32\notepad.exe";

IntPtr hIcon = ExtractIcon(IntPtr.Zero, filename, 0);

System.Drawing.Icon MyIcon = System.Drawing.Icon.FromHandle(hIcon);

pictureBox1.Image = MyIcon.ToBitmap();

And in .NET, we can make a call like:

System.Drawing.Icon.ExtractAssociatedIcon(fileName);

        Performance optimisation in .NET is not limited to what I have shared here. There are numerous other things that can be done to improve. Not every solution fits in every situation. There are cases where the solution can actually degrade your performance if you blindly go on implementing the tips and tricks.

        Hope this blog help you in optimising your .NET app.