DEV Community: Emad Hassan Khan

Journey from 82289ms to 975ms: Optimizing a Heavy Query in .NET Core

Emad Hassan Khan — Fri, 01 Mar 2024 20:14:28 +0000

Introduction: The Quest for Speed
Unveiling the Challenge: A 82289ms Monster
Analyzing the Culprit: Understanding the Code
The Road to Optimization: Strategies Employed
Refactored Elegance: Witnessing the Transformation
Lessons Learned: Insights and Reflections
Conclusion: From Struggle to Success

Introduction: The Quest for Speed

In the world of software development, optimization isn’t just a goal; it’s a necessity. Recently, I embarked on a journey to tame a beast of a query that was gobbling up precious milliseconds. What began as a daunting challenge ultimately turned into a triumph of efficiency and ingenuity.

Unveiling the Challenge: A 82289ms Monster

The journey began when I encountered a query that seemed to defy the laws of efficiency. Clocking in at a staggering 82289ms, it was clear that drastic measures were needed. The culprit? A tangled web of Include and ThenInclude calls fetching a colossal number of rows from our SQL Server database.

Analyzing the Culprit: Understanding the Code

Diving into the code, I meticulously dissected each line, searching for bottlenecks and inefficiencies. It became evident that the excessive data retrieval was the primary culprit behind the sluggish performance. With approximately 60k rows being fetched, it was no wonder the query was struggling to keep pace.

The Road to Optimization: Strategies Employed

Armed with insight and determination, I set out to optimize the query. Employing a combination of techniques including eager loading, selective data retrieval, and caching, I systematically tackled each bottleneck head-on. Through careful analysis and experimentation, I fine-tuned the code, inching closer to my goal with each optimization.

Refactored Elegance: Witnessing the Transformation

The moment of truth arrived as I executed the refactored code. Anticipation hung in the air as the query sprung to life, executing with lightning speed. In a remarkable transformation, the execution time plummeted from 82289ms to a mere 975ms. The satisfaction of witnessing such a dramatic improvement was immeasurable.

Lessons Learned: Insights and Reflections

The journey of optimizing a heavy query taught me valuable lessons that extend beyond mere technical proficiency. It underscored the importance of patience, perseverance, and a willingness to challenge conventional wisdom. It also highlighted the power of collaboration and knowledge sharing within the developer community.

Conclusion: From Struggle to Success

In conclusion, the story of optimizing a heavy query in .NET Core is a testament to the endless possibilities that lie within the realm of software development. While the road may be fraught with challenges, with the right tools, techniques, and mindset, any obstacle can be overcome. As we continue to push the boundaries of what’s possible, let us embrace each challenge as an opportunity for growth and innovation.

Have you encountered similar challenges in your development journey? Share your experiences and insights in the comments below. Together, let’s celebrate the triumphs and tribulations that unite us as developers on a quest for excellence.

Don’t use filter method on Large Datasets!

Emad Hassan Khan — Fri, 17 Mar 2023 08:12:00 +0000

I was working on the application in which I faced a performance issue, the issue was related to the fact that I used a grid in Angular application and on the grid I was triggering a click event on the td element of the table.

In the method attached to that td I was passing the index of the row and on the .ts file I used .filter method of array, later I realized that if the array size reaches to 5000 records then this will hit a performance bottleneck.

So I decided to use the for loop instead of filter and it boosted my performance to the level I can’t imagine. Here’s the code for your reference:

Cache API calls in Angular using Interceptor

Emad Hassan Khan — Sat, 04 Mar 2023 09:27:12 +0000

Developing web applications can be a challenging task, and among the many issues we face, one of the most common ones is the repetitive API calls that occur every time a component initializes. This can lead to a great deal of pain and frustration, as well as excessive calls that can slow down the performance of your application.

But fear not, there is a strategy that can help you save multiple API hits for the same endpoint. By making use of an Interceptor in your Angular application, you can streamline your code and improve the overall efficiency of your web app.

In the code snippet below, we will demonstrate how to implement this strategy by simply mentioning the endpoints we want to cache and letting the interceptor do its job. This will not only save you time and energy, but also make your application more responsive and user-friendly.

So without further ado, let’s dive in and discover how to implement this powerful tool in your web development process.

Here’s the code:

After the interceptor is created don’t forget to reference it in app.module.ts

Alright, lets catch the code explanation:

We have an Angular interceptor called ApiCacheInterceptor that can cache HTTP responses from certain API endpoints. The interceptor uses the HttpInterceptor class and its intercept() method to handle all HTTP requests and responses.

When a request is intercepted, the interceptor checks if the request endpoint is in a predefined set of endpoints to cache. If the endpoint is in the set, the interceptor checks if the response is already cached. If the response is cached, the interceptor returns the cached response. If the response is not cached, the interceptor sends the request to the server, caches the response, and returns the response to the original caller.

The ApiCacheInterceptor class defines two private properties: cache, which is a Map object that stores cached responses, and endpointsToCache, which is a Set object that lists the endpoints to cache. The intercept() method uses these properties to implement the caching logic.

If you found this article informative and helpful, make sure to follow my account for more insightful and useful posts on various topics related to web development, technology, and much more. By following, you’ll be the first to know about my latest articles, tips, and tricks, and stay up to date with the latest trends in the industry.

I am dedicated to providing high-quality content that is easy to understand and helpful for readers of all levels of expertise. Whether you’re a beginner or an experienced developer, you’ll find my posts to be informative, engaging, and relevant to your interests.