Best Practices to Improve ASP.net Web Application Performance
Transcript of Best Practices to Improve ASP.net Web Application Performance
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 1/15
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 2/15
Since ASP.NET manages session state by default, you pay the cost in memory
even if you don't use it, i.e., whether you store your data in-process or on
state server or in a SQL database, session state requires memory and it's also
time consuming when you store or retrieve data from it.
Solution
You may not require session state when your pages are static or when you
do not need to store information captured in the page.
In such cases where you need not use session state, disable it on your web
form using the directive:
<@%Page EnableSessionState="false"%>
In case you use the session state only to retrieve data from it and not toupdate it, make the session state read only by using the directive:
<@%Page EnableSessionState ="ReadOnly"%>
3. Disable View State of a Page if possible
View state is a fancy name for ASP.NET storing some state data in a hidden
input field inside the generated page. When the page is posted back to the
server, the server can parse, validate, and apply this view state data back to
the page's tree of controls.
View state is a very powerful capability since it allows state to be persisted
with the client and it requires no cookies or server memory to save this state.
Many ASP.NET server controls use view state to persist settings made during
interactions with elements on the page, for example, saving the current page
that is being displayed when paging through data.
How it affects performance
1. There are a number of drawbacks to the use of view state, however.
2. It increases the total payload of the page both when served and whenrequested. There is also an additional overhead incurred when
serializing or deserializing view state data that is posted back to the
server.
3. View state increases the memory allocations on the server. Several
server controls, the most well known of which is the DataGrid, tend
to make excessive use of view state, even in cases where it is not
needed.
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 3/15
Solution
Pages that do not have any server postback events can have the view state
turned off.
The default behavior of the ViewState property is enabled, but if you don'tneed it, you can turn it off at the control or page level. Within a control,
simply set theEnableViewState property to false, or set it globally within
the page using this setting:
<%@ Page EnableViewState="false" %>
If you turn view state off for a page or control, make sure you thoroughly test
your pages to verify that they continue to function correctly.
4. Set debug=false in web.config
When you create the application, by default this attribute is set to "true"
which is very useful while developing. However, when you are deploying your
application, always set it to "false".
How it affects performance
Setting it to "true" requires the PDB information to be inserted into the file
and this results in a comparatively larger file and hence processing will be
slow.
Solution
Therefore, always set debug="false" before deployment.
5. Avoid Response.Redirect
Response.Redirect() method simply tells the browser to visit another
page.
How it affects performance
Redirects are also very chatty. They should only be used when you are
transferring people to another physical web server.
Solution
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 4/15
For any transfers within your server, use .transfer! You will save a lot of
needless HTTP requests. Instead of telling the browser to redirect, it simply
changes the "focus" on the Web server and transfers the request. This means
you don't get quite as many HTTP requests coming through, which therefore
eases the pressure on your Web server and makes your applications run
faster.
Tradeoffs
1. ".transfer" process can work on only those sites running on the
server. Only Response.Redirect can do that.
2. Server.Transfer maintains the original URL in the browser. This
can really help streamline data entry techniques, although it may
make for confusion when debugging
5. A) To reduce CLR Exceptions count, use Response.Redirect
(".aspx", false) instead of response.redirect (".aspx").
6. Use the String builder to concatenate string
How it affects performance
String is Evil when you want to append and concatenate text to
your string. All the activities you do to the string are stored in the
memory as separate references and it must be avoided as much as possible.
i.e. When a string is modified, the run time will create a new string andreturn it, leaving the original to be garbage collected. Most of the time, this is
a fast and simple way to do it, but when a string is being modified
repeatedly, it begins to be a burden on performance: all of those allocations
eventually get expensive.
Solution
Use String Builder whenever string concatenation is needed so that it only
stores the value in the original string and no additional reference is
created.
7. Avoid throwing exceptions
How it affects performance
Exceptions are probably one of the heaviest resource hogs and causes of
slowdowns you will ever see in web applications, as well as windows
applications.
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 5/15
Solution
You can use as many try /catch blocks as you want. Using exceptions
gratuitously is where you lose performance. For example, you should stay
away from things like using exceptions for control flow.
8. Use Finally Method to kill resources
1. The finally method gets executed independent of the outcome of
the Block.
2. Always use the finally block to kill resources like closing database
connection, closing files and other resources such that they get
executed independent of whether the code worked in Try or went
to Catch.
9. Use Client Side Scripts for validations
User Input is Evil and it must be thoroughly validated before processing to
avoid overhead and possible injections to your applications.
How It improves performance
Client site validation can help reduce round trips that are required to process
user's request. In ASP.NET, you can also use client side controls to validate
user input. However, do a check at the Server side too to avoid the infamous
JavaScript disabled scenarios.
10. Avoid unnecessary round trips to the server
How it affects performance
Round trips significantly affect performance. They are subject to network
latency and to downstream server latency. Many data-driven Web sites
heavily access the database for every user request. While connection pooling
helps, the increased network traffic and processing load on the database
server can adversely affect performance.
Solution
1. Keep round trips to an absolute minimum
2. Implement Ajax UI whenever possible. The idea is to avoid full page
refresh and only update the portion of the page that needs to be
changed
11. Use Page.ISPostBack
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 6/15
Make sure you don't execute code needlessly.
Use Page.ISPostBack property to ensure that you only perform page
initialization logic when a page is first time loaded and not in response to
client postbacks.
12. Include Return Statements with in theFunction/Method
How it improves performance
Explicitly using return allows the JIT to perform slightly more optimizations.
Without a return statement, each function/method is given several local
variables on stack to transparently support returning values without the
keyword. Keeping these around makes it harder for the JIT to optimize, and
can impact the performance of your code. Look through your
functions/methods and insert return as needed. It doesn't change the
semantics of the code at all, and it can help you get more speed from your
application.
13. Use Foreach loop instead of For loop for String
Iteration
Foreach is far more readable, and in the future it will become as fast as
a For loop for special cases like strings. Unless string manipulation is a
real performance hog for you, the slightly messier code may not be worth it.
14. Avoid Unnecessary Indirection
How it affects performance
When you use byRef, you pass pointers instead of the actual object.
Many times, this makes sense (side-effecting functions, for example), but you
don't always need it. Passing pointers results in more indirection, which is
slower than accessing a value that is on the stack.
Solution
When you don't need to go through the heap, it is best to avoid it there by
avoiding indirection.
15. Use "ArrayLists" in place of arrays
How it improves performance
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 7/15
An ArrayList has everything that is good about an array PLUS automatic
sizing, Add, Insert, Remove, Sort, Binary Search. All these great helper
methods are added when implementing the IList interface.
Tradeoffs
The downside of an ArrayList is the need to cast objects upon retrieval.
16. Always check Page.IsValid when using ValidatorControls
Always make sure you check Page.IsValid before processing your forms
when using Validator Controls.
17. Use Paging
Take advantage of paging's simplicity in .NET. Only show small subsets of
data at a time, allowing the page to load faster.
Tradeoffs
Just be careful when you mix in caching. Don't cache all the data in the grid.
18. Store your content by using caching
How it improves performance
ASP.NET allows you to cache entire pages, fragment of pages or controls. You
can also cache variable data by specifying the parameters on which the data
depends. By using caching, you help ASP.NET engine to return data for
repeated request for the same page much faster.
When and Why Use Caching
A proper use and fine tune of caching approach will result in better
performance and scalability of your site. However, improper use of caching
will actually slow down and consume lots of your server performance and
memory usage.
Good candidate to use caching is if you have infrequent chance of data or
static content of web page.
19. Use low cost authentication
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 8/15
Authentication can also have an impact over the performance of your
application. For example, passport authentication is slower than form-base
authentication which in here turn is slower than Windows authentication.
20. Minimize the number of web server controls
How it affects performance
The use of web server controls increases the response time of your
application because they need time to be processed on the server side before
they are rendered on the client side.
Solution
One way to minimize the number of web server controls is by taking into
consideration, the usage of HTML elements where they are suited, for
example if you want to display static text.
21. Avoid using unmanaged code
How it affects performance
Calls to unmanaged code are a costly marshaling operation.
Solution
Try to reduce the number calls between the managed and unmanaged code.
Consider doing more work in each call rather than making frequent calls to do
small tasks.
22. Avoid making frequent calls across processes
If you are working with distributed applications, this involves additional
overhead negotiating network and application level protocols. In this case,
network speed can also be a bottleneck. Try to do as much work as possible
in fewer calls over the network.
23. Cleaning Up Style Sheets and Script Files1. A quick and easy way to improve your web application's performance
is by going back and cleaning up your CSS Style Sheets and Script
Files of unnecessary code or old styles and functions. It is common for
old styles and functions to still exist in your style sheets and script files
during development cycles and when improvements are made to a
website.
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 9/15
2. Many websites use a single CSS Style Sheet or Script File for the entire
website. Sometimes, just going through these files and cleaning them
up can improve the performance of your site by reducing the page
size. If you are referencing images in your style sheet that are no
longer used on your website, it's a waste of performance to leave them
in there and have them loaded each time the style sheet is loaded.3. Run a web page analyzer against pages in your website so that you
can see exactly what is being loaded and what takes the most time to
load.
24. Design with ValueTypes
Use simple structs when you can, and when you don't do a lot of boxing
and unboxing.
Tradeoffs
ValueTypes are far less flexible than Objects, and end up hurting
performance if used incorrectly. You need to be very careful about when you
treat them like objects. This adds extra boxing and unboxing overhead to
your program, and can end up costing you more than it would if you had
stuck with objects.
25. Minimize assemblies
Minimize the number of assemblies you use to keep your working set small. If
you load an entire assembly just to use one method, you're paying a
tremendous cost for very little benefit. See if you can duplicate that method'sfunctionality using code that you already have loaded.
26. Encode Using ASCII When You Don't Need UTF
By default, ASP.NET comes configured to encode requests and responses as
UTF-8.
If ASCII is all your application needs, eliminating the UTF overhead can give
you back a few cycles. Note that this can only be done on a per-application
basis.
27. Avoid Recursive Functions / Nested Loops
These are general things to adopt in any programming language, which
consume lot of memory. Always avoid Nested Loops, Recursive functions, to
improve performance.
28. Minimize the Use of Format ()
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 10/15
When you can, use toString() instead of format(). In most cases, it will
provide you with the functionality you need, with much less overhead.
29. Place StyleSheets into the Header
Web developers who care about performance want browser to load whatevercontent it has as soon as possible. This fact is especially important for pages
with a lot of content and for users with slow Internet connections. When the
browser loads the page progressively the header, the logo, the navigation
components serve as visual feedback for the user.
When we place style sheets near the bottom part of the HTML, most browsers
stop rendering to avoid redrawing elements of the page if their styles change
thus decreasing the performance of the page. So, always
place StyleSheets into the Header.
30. Put Scripts to the end of Document
Unlike StyleSheets, it is better to place scripts to the end of the document.
Progressive rendering is blocked until all StyleSheets have been
downloaded. Scripts cause progressive rendering to stop for all content below
the script until it is fully loaded. Moreover, while downloading a script, the
browser does not start any other component downloads, even on different
hostnames.
So, always have scripts at the end of the document.
31. Make JavaScript and CSS External
Using external files generally produces faster pages because the JavaScript
and CSS files are cached by the browser. Inline JavaScript and CSS increase
the HTML document size but reduce the number of HTTP requests. With
cached external files, the size of the HTML is kept small without increasing the
number of HTTP requests thus improving the performance.
Tips For Database Operations
1. Return Multiple Resultsets
If the database code has request paths that go to the database more than
once, then these round-trips decrease the number of requests per second
your application can serve.
Solution
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 11/15
Return multiple resultsets in a single database request, so that you can cut
the total time spent communicating with the database. You'll be making your
system more scalable, too, as you'll cut down on the work the database
server is doing managing requests.
2. Connection Pooling and Object Pooling
Connection pooling is a useful way to reuse connections for multiple requests,
rather than paying the overhead of opening and closing a connection for each
request. It's done implicitly, but you get one pool per unique connection
string. Make sure you call Close or Dispose on a connection as soon as
possible. When pooling is enabled, calling Close orDispose returns the
connection to the pool instead of closing the underlying database connection.
Account for the following issues when pooling is a part of your design:
1. Share connections
2. Avoid per-user logons to the database
3. Do not vary connection strings
4. Do not cache connections
3. Use SqlDataReader Instead of Dataset wherever it ispossible
If you are reading a table sequentially, you should use
the DataReader rather than DataSet. DataReader object creates a read
only stream of data that will increase your application performance because
only one row is in memory at a time.
4. Keep Your Datasets Lean
Remember that the dataset stores all of its data in memory, and that the
more data you request, the longer it will take to transmit across the wire.
Therefore, only put the records you need into the dataset.
5. Avoid Inefficient queries
How it affects performance
Queries that process and then return more columns or rows than necessary
waste processing cycles that could best be used for servicing other requests.
Cause of Inefficient queries
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 12/15
1. Too much data in your results is usually the result of inefficient
queries.
2. The SELECT * query often causes this problem. You do not usually
need to return all the columns in a row. Also, analyze
the WHERE clause in your queries to ensure that you are not returning
too many rows. Try to make the WHERE clause as specific as possibleto ensure that the least number of rows are returned.
3. Queries that do not take advantage of indexes may also cause poor
performance.
6. Unnecessary round trips
How it affects performance
Round trips significantly affect performance. They are subject to network
latency and to downstream server latency. Many data-driven Web sites
heavily access the database for every user request. While connection pooling
helps, the increased network traffic and processing load on the database
server can adversely affect performance.
Solution
Keep round trips to an absolute minimum.
7. Too many open connections
Connections are an expensive and scarce resource, which should be shared
between callers by using connection pooling. Opening a connection for eachcaller limits scalability.
Solution
To ensure the efficient use of connection pooling, avoid keeping connections
open and avoid varying connection strings.
8. Avoid Transaction misuse
How it affects performance
If you select the wrong type of transaction management, you may add
latency to each operation. Additionally, if you keep transactions active for
long periods of time, the active transactions may cause resource pressure.
Solution
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 13/15
Transactions are necessary to ensure the integrity of your data, but you need
to ensure that you use the appropriate type of transaction for the shortest
duration possible and only where necessary.
9. Avoid Over Normalized tables
Over Normalized tables may require excessive joins for simple operations.
These additional steps may significantly affect the performance and scalability
of your application, especially as the number of users and requests increases.
10. Reduce Serialization
Dataset serialization is more efficiently implemented in .NET Framework
version 1.1 than in version 1.0. However, Dataset serialization often
introduces performance bottlenecks.
You can reduce the performance impact in a number of ways:
1. Use column name aliasing
2. Avoid serializing multiple versions of the same data
3. Reduce the number of DataTable objects that are serialized
11. Do Not Use CommandBuilder at Run Time
How it affects performance
CommandBuilder objects such
as SqlCommandBuilder and OleDbCommandBuilder are useful when you
are designing and prototyping your application. However, you should not use
them in production applications. The processing required to generate the
commands affects performance.
Solution
Manually create stored procedures for your commands, or use the Visual
Studio® .NET design-time wizard and customize them later if necessary.
12. Use Stored Procedures Whenever Possible
1. Stored procedures are highly optimized tools that result in excellent
performance when used effectively.
2. Set up stored procedures to handle inserts, updates, and deletes with
the data adapter
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 14/15
3. Stored procedures do not have to be interpreted, compiled or even
transmitted from the client, and cut down on both network traffic and
server overhead.
4. Be sure to use CommandType.StoredProcedure instead
of CommandType.Text
13. Avoid Auto-Generated Commands
When using a data adapter, avoid auto-generated commands. These require
additional trips to the server to retrieve meta data, and give you a lower level
of interaction control. While using auto-generated commands is convenient,
it's worth the effort to do it yourself in performance-critical applications.
14. Use Sequential Access as Often as Possible
With a data reader, use CommandBehavior.SequentialAccess. This is
essential for dealing with blob data types since it allows data to be read off of
the wire in small chunks. While you can only work with one piece of the data
at a time, the latency for loading a large data type disappears. If you don't
need to work the whole object at once, using Sequential Access will give you
much better performance.
Tips for ASP.NET Applications Developed using VB
1. Enable Option Strict and Option Explicit for your pages
With Option Strict on, you protect yourself from inadvertent late binding and
enforce a higher level of coding discipline.
2. Use early binding in Visual Basic or JScript code
Visual Basic 6 does a lot of work under the hood to support casting of objects,
and many programmers aren't even aware of it. In Visual Basic 7, this is an
area out of which you can squeeze a lot of performance.
Solution
When you compile, use early binding. This tells the compiler to insert a Type
Coercion is only done when explicitly mentioned.
This has two major effects:
1. Strange errors become easier to track down.
2. Unneeded coercions are eliminated, leading to substantial performance
improvements.
8/6/2019 Best Practices to Improve ASP.net Web Application Performance
http://slidepdf.com/reader/full/best-practices-to-improve-aspnet-web-application-performance 15/15
3. When you use an object as if it were of a different type, Visual Basic
will coerce the object for you if you don't specify. This is handy since
the programmer does not have to worry about less code.
3. Put Concatenations in One Expression
If you have multiple concatenations on multiple lines, try to stick them all onone expression. The compiler can optimize by modifying the string in place,
providing a speed and memory boost. If the statements are split into multiple
lines, the Visual Basic compiler will not generate the Microsoft Intermediate
Language (MSIL) to allow in-place concatenation.