Performance should be a continuous consideration in the development process, rather than an afterthought during debugging. However, it’s often viewed as a mysterious art, driven by intuition and necessity.
Developers frequently rely on their instincts, focusing on code sections they believe to be slow. The risk here is that you might achieve a significant speed improvement (which is great) in a section of code that only contributes a small fraction to the overall user experience (not so great). Worse still, your assumptions may be entirely incorrect, and there might not be a problem where you were looking.
This method of optimization is slow, tedious, and frankly, costly. To state the obvious, if you want to avoid wasting time searching for real issues, then when it’s time to optimize, don’t guess. Instead, use one of the many available tools and profilers to measure where time or memory is being consumed. Focus your efforts where a change will have the greatest impact on the overall system’s performance.
This is a principle that will be emphasized throughout this article: guessing is ineffective, and there are tools that can pinpoint your problems precisely, so make good use of them. With that in mind, let’s explore some fundamental techniques and tools to ensure you maximize the performance of your ASP.NET applications. Let’s dive in!
Factors in Performant Applications
Writing efficient code is a skill attainable by all developers, and with the right tools and practice, it can become second nature. It’s essential to consider performance as an integral part of your daily development process rather than an afterthought when issues become more challenging and costly to resolve.
Here are some compelling reasons why you should prioritize your application’s performance from the outset:
User Experience: If users encounter a slow and frustrating experience, they may complain, leading to days spent debugging instead of creating new code.
Cost Efficiency: Improving application speed often comes down to either investing in more hardware (especially true in the cloud-web environment, where poorly optimized queries can lead to unnecessary server expenses) or optimizing your code.
Avoiding Production Headaches: Performance issues that surface in production can require significant architectural rework, causing disruptions and diverting your focus from new projects.
User Satisfaction: Delivering a well-performing application from the start is gratifying, and knowing that your users appreciate and enjoy using it is a rewarding experience.
If you’re still reading, it’s likely that you understand the benefits of optimizing your ASP.NET application for better performance. In broad terms, three key areas will impact your application’s performance:
Perception:
Let’s be honest; most applications don’t need to be developed with extreme speed in mind; they just need to be fast enough. However, it’s worth noting that users tend to complain about speed, regardless of how fast the application actually is. Humans are naturally inclined to notice slowness.
Nevertheless, the crucial perspective to keep in mind when addressing performance issues is that of the user. Always ensure that your efforts are focused on resolving issues that directly impact the user experience, rather than diving into sections of code that you suspect might be running slowly.
Compilation and Configuration:
To optimize your application, it’s important to compile your code correctly and configure the system with debug features disabled. Compiling the code in non-debug mode and with the highest level of optimization ensures that the compiler generates more efficient code (although this has other implications, which we can discuss another time). In byte code systems like .NET, debug features can hinder the JIT compiler from producing the most efficient code because the generated code includes extra information for debugging, preventing full optimization.
Additionally, make sure that both your application and the target environment are configured correctly to maximize performance. Consider factors such as maintaining an appropriate logging level for a production system to avoid unnecessary overhead, enabling compression (even for dynamic content), and implementing a sensible caching strategy for static content.
The most efficient code is the code that’s never executed. However, since code must serve a purpose, it should be crafted with performance in consideration. Let’s explore how we can maximize the efficiency of the code we write.
Tools and Techniques
I firmly believe in the principle of ‘Make it Work, Make it Right, Make it Fast’ (in that order). However, even when you focus on making it ‘Fast,’ it’s easy to misdirect your efforts toward the wrong areas. It’s prudent to begin by preventing major issues through best practices.
General Best Practices:
When it comes to achieving high performance, education is key. Developers should be well-versed in and adhere to sound coding and architectural practices. While some of these guidelines may seem obvious, it’s always beneficial to have a reminder. Adhering to these guidelines doesn’t guarantee flawless code performance, but it significantly improves the odds.
– Familiarize yourself with the Fallacies of Distributed Computing to avoid common pitfalls.
– Understand data structures, their appropriate usage, and the associated memory and access time costs (whether they are constant, linear, or exponential).
– Comprehend the differences in speed when accessing disk, reading data from memory, or retrieving it from the network, as these variations can span orders of magnitude.
Most importantly, continuously educate yourself about and adhere to established development practices, such as performing paging and sorting on the database instead of in code, using caching effectively, ensuring proper database indexing, minifying and bundling CSS and
JavaScript files for reduced network connections, and more. Resources like Stack Overflow and compilations of proven performance advice from fellow developers can help you. One such compilation is Red Gate’s free eBook titled ’50 Ways to Avoid, Find, and Fix ASP.NET Performance Issues.’
Even when following these guidelines and using best practices, mistakes can occur. The earlier you detect them, the less impact they’ll have, and the easier they’ll be to rectify.
During development, I typically rely on two tools to identify most issues. Starting with the database layer, many performance problems originate there, so let’s address that aspect first:
SQL Profiler:
During development, one of the techniques I frequently employ is keeping SQL Profiler constantly open while the application is in use. To make this practice effective, having more than one monitor is advisable, as it enables simultaneous monitoring of the application and the database. This approach allows me to continually track the executed queries and quickly identify certain aspects with minimal effort:
Number of calls: If I observe multiple queries within a single request or action, it may indicate opportunities for caching or a need to address lazy loading by implementing eager loading or prefetching. While Object-Relational Mapping (ORM) tools are valuable during development, it’s easy to unintentionally misuse the database without understanding its underlying operations. Keeping a profiler active helps maintain database efficiency.
Slow Queries: If I notice queries taking excessive time to execute, it could signal missing indexes, unoptimized queries, or poor join conditions.
Data Volume: When there’s an excessive amount of data being retrieved, it might indicate issues with paging implementation or mishandling of data.
Physical Reads: A high number of physical reads resulting from queries often suggests the possibility of missing indexes.
One crucial takeaway is the importance of using a realistic dataset for testing during development. Without such data, identifying database-related issues like data structures, configurations, or optimizations can become exceedingly difficult.
If your team uses a shared database for development, a prudent practice is to apply filters to monitor only the calls made by your machine or database user.
Now that we’ve established a method for monitoring the application’s data store during development, let’s explore how to monitor the application code itself.
Glimpse:
Another invaluable tool I frequently use during development is Glimpse. This open-source ASP.NET module (available for free) provides a wealth of information about your application code and server. Glimpse offers instant insights into various aspects, including request data (such as request parameters, configured routes, server variables, and sessions), server configuration and environment, the pipeline and methods called (including their execution times), and AJAX calls, among other things. It’s a powerful resource for gaining visibility into your application’s inner workings.
Conclusion
In the development process, it’s crucial to prioritize performance considerations right from the beginning. Performance isn’t solely a result of code; it’s also influenced by user perception, application compilation/configuration, and the code itself, working in conjunction with databases and external services. To optimize your code effectively, continuous education and a strong understanding of common best practices are essential.
Additionally, it’s vital to constantly monitor how your code interacts with databases and external services during development and keep this in mind when troubleshooting and optimizing. Tools like Glimpse and SQL Profiler provide real-time insights into your application’s performance, enabling you to address issues promptly. Avoid relying on speculation, manual timing statements, or guesswork to identify performance problems; instead, leverage the available tools to gain a comprehensive understanding of your entire application, ultimately saving you significant time and effort.
By adopting these practices, you’ll be better equipped to deliver a high-performing application that meets user expectations and functions efficiently across the board.
