Episode 1 : What is .AsNoTracking() and its benefits

Episode 2 : SingleAsync and FirstAsync Methods of LINQ in .NET

Episode 3 : Basic overview of Monolithic and Microservices applications

Episode 4 : Difference b/w Boxing and Unboxing in C#

Episode 5 : Benefit of using AsReadOnly Method of List in .NET

Episode 6 : Difference b/w Any and All Method for Collection in .NET

Episode 7 : Lazy Loading vs Eager Loading in EntityFramework

Episode 8 : Aggregate function over List by Default Provided

Episode 9 : Difference b/w Include and ThenInclude in Entity Framework

Episode 10 : Use ToQueryString() Extension method while debugging

Episode 11 : How to avoid DbContext threading issues in Entity Framework

Episode 12 : How to register Open Generics in .NET Core Dependency Injection

Episode 13 : What are CORS and how to enable them in .NET at API Level

Episode 14 : Common Middlewares in .NET API

Episode 15 : Response Compression in .NET Core and how to configure its middleware

Episode 16 : Count() vs TryGetNonEnumeratedCount() and Which one is better ?

Episode 17 : Everything about Rate Limiting in .NET

Episode 18 : A basic visit to Response Caching along with its implementation in .NET

Episode 19 : Do you know how to initialize an Empty Enumerable in .NET ?

Episode 20 : Dependency Injection Explained in .NET

Episode 21 : IEnumerable vs IQueryable in .NET

Episode 22 : Why is it generally considered good practice to keep Dependency Injections in seperate class !

Episode 23 : Difference b/w GetType() and typeOf() Methods in .NET

Episode 24 : Difference b/w VAR and DYNAMIC keyword in C#

Episode 25 : StringBuilder vs string in C#

𝐖𝐡𝐢𝐥𝐞 𝐮𝐬𝐢𝐧𝐠 𝐀𝐬𝐍𝐨𝐓𝐫𝐚𝐜𝐤𝐢𝐧𝐠 1. The entity is not tracked by the context. 2. EF does not know the state of its entity. 3 Not recommended when you are performing Add/Update/Delete kind operations 4. Improved performance over regular LINQ queries. 5. Only recommended when you are doing read-only operations. 6. Most efficient when we have to retrieve large set of data.

𝐖𝐢𝐭𝐡𝐨𝐮𝐭 𝐀𝐬𝐍𝐨𝐓𝐫𝐚𝐜𝐤𝐢𝐧𝐠 1. The entity is tracked by the context. 2. EF knows the state of this entity. 3. We can use this entity to save/update and we don't need to set the state of entity again.

1. In .NET, SingleAsync and FirstAsync are methods that can be used to retrieve a single element from a collection of elements.
2. Both methods are similar in that they return the first element in a collection that satisfies a specified condition.
3. The main difference between SingleAsync and FirstAsync is that SingleAsync will throw an exception if there is more than one element in the collection that satisfies the specified condition, while FirstAsync will return the first element it finds and then stop.
4. SingleAsync can be used to ensure that there is exactly one element in the collection that satisfies the condition, while FirstAsync can be used to simply retrieve the first element that satisfies the condition, regardless of how many elements in the collection satisfy the condition.

Lets see the difference b/w monolithic and microservices

𝐌𝐨𝐧𝐨𝐥𝐢𝐭𝐡𝐢𝐜:

1. A monolithic application is a single, self-contained program that consists of a single codebase.
2. It is typically built and deployed as a single unit
3. It tends to be more tightly coupled
4. It can be more brittle, since a failure in one part of the application can affect the entire system

𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞𝐬:

1. A microservices application is a collection of small, independent services that communicate with each other to form a complete application.
2. It is built as a set of independent services that are deployed and managed separately
3. It is flexible and scalable as individual services can be updated and deployed without affecting the entire application.
4. It tends to be loosely coupled.
5. These applications can be more complex to build and manage, since they require coordination among multiple services.
6. They can also be more expensive to run, since each service needs to be individually managed and scaled.

𝐁𝐨𝐱𝐢𝐧𝐠 and 𝐔𝐧𝐛𝐨𝐱𝐢𝐧𝐠 are used to convert value types to reference types and vice versa. When value type is moved to a reference type it’s called as 𝐁𝐨𝐱𝐢𝐧𝐠 . The vice-versa is termed as 𝐔𝐧𝐛𝐨𝐱𝐢𝐧𝐠.

Here are some benefits of 𝐀𝐬𝐑𝐞𝐚𝐝𝐎𝐧𝐥𝐲 Method of 𝐋𝐢𝐬𝐭<𝐓>

1. It gives you read only view of your collection.
2. It allows you to prevent the collection from being modified, either accidentally or intentionally
3. It can improve the performance of your code in some cases because the read-only wrapper provides a more restricted view of the collection.
4. This can be particularly beneficial when working with large collections, where even small performance improvements can make a significant difference.

𝐀𝐧𝐲 𝐯𝐬 𝐀𝐥𝐥 𝐄𝐱𝐭𝐞𝐧𝐬𝐢𝐨𝐧 𝐌𝐞𝐭𝐡𝐨𝐝 𝐨𝐟 𝐋𝐢𝐬𝐭<𝐓>

1.The 𝐀𝐥𝐥 method checks if all elements of a list satisfy a specified condition.

2.The 𝐀𝐧𝐲 method checks if any elements of a list satisfy a specified condition.

𝐋𝐚𝐳𝐲 𝐋𝐨𝐚𝐝𝐢𝐧𝐠 (𝐋𝐋)

1. Lazy Loading is a process where EF loads the related entities on demand.

2. It is the default behavior of EF

3. It delays the loading of related entities until you specifically request it.

4. You can go with it when you are sure that you are not using the related entities Instantly.

5. The number of round trips to the database is more as for each master entity data, it will issue a separate SQL query to get the child-related entity data.

6. It simply uses the SELECT Statement without any join.

7. If you are not interested in related entities or the related entities are not used instantly, then you can use it.

𝐄𝐚𝐠𝐞𝐫 𝐋𝐨𝐚𝐝𝐢𝐧𝐠 (𝐄𝐋)

1. Eager loading is a Process where EF loads the related entities along with the main entity

2. EF will not execute separate SQL queries for loading the related entities.

3. All the entities are loaded from the database with a single query saving bandwidth and server CPU time.

4. You can go with EL when you are sure that you will be using the related entities with the main entity everywhere

5. It is a good practice to reduce the number of SQL queries to be sent to the database server to fetch the related entities

6. It will use SQL Joining to join the related tables with the main table and then return the Main entity data along with the related entities.

7. If you are interested in related entities used instantly in your application, then you need to go with it.

𝐍𝐨𝐭𝐞 : If you want to check the 𝐒𝐐𝐋 𝐆𝐞𝐧𝐞𝐫𝐚𝐭𝐞𝐝 𝐐𝐮𝐞𝐫𝐲 when a LINQ query executes then you can check it by clicking on 𝐓𝐨𝐨𝐥𝐬 -> 𝐒𝐐𝐋 𝐒𝐞𝐫𝐯𝐞𝐫 𝐏𝐫𝐨𝐟𝐢𝐥𝐞𝐫 in SQL Server Management Studio.

You would be familiar with aggregate functions from SQL, let’s see how to use Entity Framework Queryable Extension Methods for aggregate functions over the List

1. Sum
2. Average
3. Minimum
4. Maximum
5. Count

.NET 6.0 has 12 overloads of these all methods for all numeric data types used in code ⏬

Include and ThenInclude are two methods in EF that can be useful for improving the performance of a query by reducing the number of databases round trips.

Include is used for eager loading that’s why related entities come in a single query and database round trips are reduced.

Main difference b/w them is level, include is used for 𝐒𝐢𝐧𝐠𝐥𝐞 𝐋𝐞𝐯𝐞𝐥 travelling along entities and ThenInclude is helpful in 𝐌𝐮𝐥𝐭𝐢𝐥𝐞𝐯𝐞𝐥 𝐑𝐞𝐭𝐫𝐢𝐞𝐯𝐚𝐥.

ToQueryString is a custom extension method that converts IQueryable to SQL Query at the back-end side, especially helpful for debugging. ⏬

When EF Core detects an attempt to use a DbContext instance concurrently, you'll see an InvalidOperationException with a message like this:

"A second operation started in this context before a previous operation was completed."

There are few ways that can help you to avoid threading issues in EF.

1. Use a separate DbContext instance for each thread. This ensures that each thread has its own DbContext instance, which means that there is no shared state between threads and no potential for threading conflicts.

𝐏𝐫𝐨𝐛𝐥𝐞𝐦: Costly in terms of memory usage

2. Use a thread-safe DbContext wrapper. In this approach, you would create a wrapper class for DbContext that uses synchronization techniques, such as the lock keyword to ensure that only one thread can access the DbContext instance at a time.

𝐏𝐫𝐨𝐛𝐥𝐞𝐦: It can impact performance because threads may have to wait for access to the DbContext instance.

3. Use 𝐚𝐬𝐲𝐧𝐜𝐡𝐫𝐨𝐧𝐨𝐮𝐬 methods that allows you to write code that can run concurrently on multiple threads. It can help improve the performance of your application by allowing multiple operations to be executed concurrently. We can use 𝐚𝐰𝐚𝐢𝐭 and 𝐚𝐬𝐲𝐧𝐜 to perform asynchronous operation.

I have so far used 𝐚𝐬𝐲𝐧𝐜𝐡𝐫𝐨𝐧𝐨𝐮𝐬 methods, which one do you practice frequently?

If you have a generic interface and its generic implementation like we mostly do when we make a generic repository for CRUD operations and you want to register its dependency injection at startup, then there is a simple way of registering the DI.

1. For .NET 3.1 register in ConfigureServices in 𝐒𝐭𝐫𝐚𝐭𝐮𝐩.𝐜𝐬

2. For latest versions of .NET(6.0 ,7.0) register in 𝐏𝐫𝐨𝐠𝐫𝐚𝐦.𝐜𝐬

CORS stands for Cross Origin Resource sharing, so what exactly is cross origin.

These two URLs have the same origin: 𝗁𝗍𝗍𝗉𝗌://𝗆𝗒-𝗌𝗂𝗍𝖾-𝗇𝗈-𝟣.𝖼𝗈𝗆/𝖦𝖾𝗍/𝖧𝖺𝗄𝗎𝗇𝖺𝖬𝖺𝗍𝖺𝗍𝖺 𝗁𝗍𝗍𝗉𝗌://𝗆𝗒-𝗌𝗂𝗍𝖾-𝗇𝗈-𝟣.𝖼𝗈𝗆/𝖦𝖾𝗍/𝖠𝗅𝗅𝖨𝗌𝖶𝖾𝗅𝗅

These URLs have different origins 𝗁𝗍𝗍𝗉𝗌://𝗆𝗒-𝗌𝗂𝗍𝖾-𝗇𝗈-𝟣.𝖼𝗈𝗆/𝖦𝖾𝗍/𝖧𝖺𝗄𝗎𝗇𝖺𝖬𝖺𝗍𝖺𝗍𝖺 𝗁𝗍𝗍𝗉://𝗆𝗒-𝗌𝗂𝗍𝖾-𝗇𝗈-𝟣.𝗇𝖾𝗍/𝖦𝖾𝗍/𝖠𝗅𝗅𝖨𝗌𝖶𝖾𝗅𝗅

To facilitate requests from different origins you need to enable CORS in .NET.

In .NET 6 by using the combination of these methods you can enable CORS as per your requirement.

𝐀𝐥𝐥𝐨𝐰𝐀𝐧𝐲𝐎𝐫𝐢𝐠𝐢𝐧: This policy allows requests from any origin.

𝐖𝐢𝐭𝐡𝐎𝐫𝐢𝐠𝐢𝐧𝐬: This policy allows requests from specific origins. You can specify one or more origins as arguments to this method.

𝐀𝐥𝐥𝐨𝐰𝐀𝐧𝐲𝐇𝐞𝐚𝐝𝐞𝐫: This policy allows requests with any header.

𝐖𝐢𝐭𝐡𝐇𝐞𝐚𝐝𝐞𝐫𝐬: This policy allows requests with specific headers. You can specify one or more headers as arguments to this method.

𝐀𝐥𝐥𝐨𝐰𝐀𝐧𝐲𝐌𝐞𝐭𝐡𝐨𝐝: This policy allows requests with any HTTP method (e.g., GET, POST, PUT, DELETE).

𝐖𝐢𝐭𝐡𝐌𝐞𝐭𝐡𝐨𝐝𝐬: This policy allows requests with specific HTTP methods. You can specify one or more methods as arguments to this method.

Few Things to Keep in mind

✔️CORS is not a security feature. CORS is a W3C standard that allows a server to relax the same-origin policy.

✔️An API isn't safer by allowing CORS.

✔️It's a way for a server to allow browsers to execute a cross-origin request that otherwise would be forbidden.

✔️Browsers without CORS can't do cross-origin requests.

Middleware is software that's assembled into an app pipeline to handle requests and responses. Each component:

Chooses whether to pass the request to the next component in the pipeline.

Can perform work before and after the next component in the pipeline.

Here are some common types of middleware that might be used in a .NET API program:

1. Routing
2. Exception handling
3. Authentication and authorization
4. CORS (Cross-Origin Resource Sharing)
5. Response compression
6. Request validation
7. Response caching 8.Static file serving

𝐑𝐨𝐮𝐭𝐢𝐧𝐠 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for determining which endpoint should handle a particular request based on the request's path and method.

𝐄𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧 𝐡𝐚𝐧𝐝𝐥𝐢𝐧𝐠 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for catching and handling exceptions that occur during the processing of a request.

𝐀𝐮𝐭𝐡𝐞𝐧𝐭𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐚𝐧𝐝 𝐚𝐮𝐭𝐡𝐨𝐫𝐢𝐳𝐚𝐭𝐢𝐨𝐧 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for verifying that a request is from an authenticated and authorized user.

𝐂𝐎𝐑𝐒 (𝐂𝐫𝐨𝐬𝐬-𝐎𝐫𝐢𝐠𝐢𝐧 𝐑𝐞𝐬𝐨𝐮𝐫𝐜𝐞 𝐒𝐡𝐚𝐫𝐢𝐧𝐠) 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for adding the necessary headers to allow a browser to make cross-origin requests to the API.

𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐜𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for compressing the response payload in order to reduce the size of the response and improve performance.

𝐑𝐞𝐪𝐮𝐞𝐬𝐭 𝐯𝐚𝐥𝐢𝐝𝐚𝐭𝐢𝐨𝐧 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for validating incoming requests to ensure that they conform to the expected format.

𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐜𝐚𝐜𝐡𝐢𝐧𝐠 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for caching responses in order to reduce the load on the server and improve performance.

𝐒𝐭𝐚𝐭𝐢𝐜 𝐟𝐢𝐥𝐞 𝐬𝐞𝐫𝐯𝐢𝐧𝐠 𝐦𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞: This middleware is responsible for serving static files, such as HTML, CSS, and JavaScript files, from the file system.

It’s important to note that the order in which middleware is added to the pipeline can be important, as the middleware will be executed in the order in which it is added. For example, if the authentication middleware is added before the routing middleware, the routing middleware will not be executed until the authentication middleware has completed.

Network bandwidth is a limited resource. Reducing the size of the response usually increases the responsiveness of an app, often dramatically. One way to reduce payload sizes is to compress an app's responses.

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 Response compression is a technique that can be used to reduce the size of HTTP responses, which can improve the performance of a web application by reducing the amount of data that needs to be transmitted over the network.

𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧

1.Improved performance: Compressing the response can reduce the amount of data that needs to be transmitted over the network, which can lead to faster page load times and a better user experience.

2.Reduced bandwidth usage: By compressing the response, you can reduce the amount of data that is transmitted over the network, which can lead to reduced bandwidth usage and lower costs for hosting and bandwidth.

3.Better SEO: Search engines take page load times into account when ranking websites, so a faster loading website may rank higher in search results.

𝐇𝐨𝐰 𝐭𝐨 𝐜𝐨𝐧𝐟𝐢𝐠𝐮𝐫𝐞 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 𝐌𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞 𝐢𝐧 .𝐍𝐄𝐓 We can configure it using the . NET middleware, AddResponseCompression.

.NET also Provides built in providers for compression we can configure their options as per our need.

1.BrotliCompressionProvider Using it a text file response at 2,044 bytes was compressed to ~979 bytes.

2. GzipCompressionProvider Using it a Scalable Vector Graphics (SVG) image response at 9,707 bytes was compresses to ~4,459 bytes

𝐔𝐑𝐋: https://bit.ly/3G3rsIj

𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 𝐋𝐞𝐯𝐞𝐥𝐬 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 - The compression operation should be optimally compressed, even if the operation, it takes a longer time to complete.

𝐅𝐚𝐬𝐭𝐞𝐬𝐭 - The compression operation should complete as quickly as possible, even if the resulting file is not optimally compressed.

𝐍𝐨 𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 - No compression should be performed on the file.

𝐒𝐦𝐚𝐥𝐥𝐞𝐬𝐭 𝐒𝐢𝐳𝐞 - The compression operation should create output as small as possible, even if the operation takes a longer time to complete.

𝐌𝐈𝐌𝐄 𝐓𝐲𝐩𝐞𝐬 𝐛𝐲 𝐃𝐞𝐟𝐚𝐮𝐥𝐭 𝐒𝐮𝐩𝐩𝐨𝐫𝐭𝐞𝐝 𝐁𝐲 .𝐍𝐄𝐓 𝐏𝐫𝐨𝐯𝐢𝐝𝐞𝐫𝐬

1. text/plain
2. text/css
3. application/javascript
4. text/html
5. application/xml
6. text/xml
7. application/json
8. text/json
9. application/wasm

𝐂𝐨𝐮𝐧𝐭()

This method will make an enumeration to calculate the count of elements.

Available in all versions of .NET

𝐓𝐫𝐲𝐆𝐞𝐭𝐍𝐨𝐧𝐄𝐧𝐮𝐦𝐞𝐫𝐚𝐭𝐞𝐝𝐂𝐨𝐮𝐧𝐭()

This attempts to determine the number of elements in a sequence without forcing an enumeration.

It is available in .NET 6 and .NET 7

It is available only on the ICollection interface.

It is typically a constant-time operation, but ultimately this depends on the complexity characteristics of the underlying collection's implementation.

Rate limiting is a technique used to control the amount of incoming and outgoing traffic to a network or service. It is often used to protect servers and other resources from being overwhelmed by too many requests, or to prevent abuses such as distributed denial of service (DDoS) attacks.

𝐇𝐨𝐰 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬? Rate limiting works by setting a limit on the number of requests that a client can make to a server within a specified time period. If the client exceeds the rate limit, the server will return an error, typically an HTTP status code 429 (Too Many Requests), to the client.

𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐑𝐚𝐭𝐞 𝐋𝐢𝐦𝐢𝐭𝐢𝐧𝐠?

1. Protecting against denial-of-service attacks of specific types.
2. Maintaining service availability.
3. Reducing resource consumption.
4. Detecting & blocking maliciousbehavior.
5. Improving user experience.

𝐂𝐨𝐧𝐬 𝐨𝐟 𝐑𝐚𝐭𝐞 𝐋𝐢𝐦𝐢𝐭𝐢𝐧𝐠? Rate limiting cannot distinguish between good and bad traffic, it will just look into IP and number of requests, so in some cases by changing the IP address attack is still possible.

𝐀𝐭 𝐰𝐡𝐢𝐜𝐡 𝐩𝐨𝐢𝐧𝐭 𝐰𝐞 𝐜𝐚𝐧 𝐚𝐩𝐩𝐥𝐲 𝐑𝐚𝐭𝐞 𝐋𝐢𝐦𝐢𝐭𝐢𝐧𝐠?

1. Network Edge
2. Application Layer
3. Database Layer
4. Service Level

𝐇𝐨𝐰 𝐜𝐚𝐧 𝐈 𝐯𝐞𝐫𝐢𝐟𝐲 𝐭𝐡𝐚𝐭 𝐑𝐚𝐭𝐞 𝐋𝐢𝐦𝐢𝐭𝐢𝐧𝐠 𝐡𝐚𝐬 𝐛𝐞𝐞𝐧 𝐚𝐝𝐝𝐞𝐝? You can check from response headers of your request there would be complete information that is your remaining limit, what is limit time etc. if your Rate Limiting has successfully configured.

𝐇𝐨𝐰 𝐭𝐨 𝐚𝐝𝐝 𝐑𝐚𝐭𝐞 𝐋𝐢𝐦𝐢𝐭𝐢𝐧𝐠 𝐢𝐧 .𝐍𝐄𝐓 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧? We can apply rate limiting on Application Layer in our project using Asp Net Core Rate Limit NuGet Package⏬

Response caching is a technique for storing the responses of an API or web application in a cache so that they can be served faster to subsequent requests. The responses are stored in a cache with a key that uniquely identifies them, and the cache has a limited size and a policy for removing items when it becomes full.

𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐚𝐜𝐡𝐢𝐧𝐠?

1. Improved performance by reducing the load on the server.

2. Reduced server load, as it can serve the cached response instead of generating a new one.

3. Reduced bandwidth usages it reduces the amount of data that needs to be transferred between the server and the client.

4. Improved security as it can reduce the number of requests that reach the server, reducing the risk of certain types of attacks.

𝐎𝐧 𝐰𝐡𝐢𝐜𝐡 𝐫𝐞𝐪𝐮𝐞𝐬𝐭𝐬 𝐰𝐞 𝐜𝐚𝐧 𝐚𝐩𝐩𝐥𝐲 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐚𝐜𝐡𝐢𝐧𝐠

1. Get
2. Head

𝐅𝐞𝐰 𝐜𝐨𝐧𝐬𝐭𝐫𝐚𝐢𝐧𝐭𝐬 𝐟𝐨𝐫 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐚𝐜𝐡𝐢𝐧𝐠 1.The request must result in a server response with a 200 (OK) status code.

2.Response Caching Middleware must be placed before middleware that require caching. For more information, see ASP.NET Core Middleware.

3.The Authorization header must not be present.

4. Cache-Control header parameters must be valid, and the response must be marked public and not marked private.

5. The Content-Length header value (if set) must match the size of the response body.

𝐒𝐨𝐦𝐞 𝐫𝐞𝐚𝐥-𝐰𝐨𝐫𝐥𝐝 𝐞𝐱𝐚𝐦𝐩𝐥𝐞𝐬 𝐨𝐟 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐚𝐜𝐡𝐢𝐧𝐠

1. News website
2. E-commerce websites In your application you can apply response caching to those requests whose response is changed after a time and you are sure about it.

𝐇𝐨𝐰 𝐜𝐚𝐧 𝐈 𝐯𝐞𝐫𝐢𝐟𝐲 𝐢𝐭? Create an application apply caching and then request it from Postman and set time to 60 minutes, you will notice that only first request will reach the controller, after that even if you try request will not reach controller.

✔️ .NET provides us the Empty() method to initialize an empty Enumerable of any type.

✔️This method is useful for passing an empty sequence to a user defined method that takes an IEnumerable ⤵️

This post crossed 100K views on my LinkedIn

Dependency injection involves providing a class with its required dependencies from an external source rather than having the class create them itself.

This helps to decouple the object creation process from the caller, leading to a more modular and flexible system.

In other words, it allows a class to focus on its core functionality rather than worrying about how to create and manage its dependencies.

𝐖𝐡𝐲 𝐝𝐨 𝐰𝐞 𝐧𝐞𝐞𝐝 𝐝𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐢𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧? By using DI classes are decoupled from each other so you make changes at one place and it is reflected all over the places.

𝐇𝐨𝐰 𝐭𝐨 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭 𝐝𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐢𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧?

✅ In .NET 6 we implement DI in Program.cs class by using builder.Services

✅ For previous versions of .NET, to implement DI we need to add the service in “ConfigureServices” method which is in Startup.cs file

𝐃𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐭 𝐰𝐚𝐲𝐬 𝐨𝐟 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐢𝐧𝐠 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐈𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧 There are three ways of doing DI:

1.Scoped ➡️ It will create an instance per scope, if we are in same scope same instance would be used. Whenever we go out of scope new instance would be created.

2. Transient ➡️ It creates new instances every time its injected.

3. Singleton ➡️ It instantiates one global object for all requests coming to the server from any user.

𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐈𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧

1.Improved testability: Dependency injection makes it easier to write unit tests for your code, as you can easily substitute mock objects for the real dependencies.

2. Enhanced flexibility: By injecting dependencies from the outside, you can easily change the implementation of a class's dependencies without having to modify the class itself. This makes it easier to adapt your application to changing requirements.

3. Increased modularity: Dependency injection encourages the use of small, single-purpose classes that are easy to test and reuse in different contexts. This can lead to a more modular and maintainable codebase.

4. Better separation of concerns: Dependency injection helps to separate the concerns of different parts of your application, making it easier to understand and maintain the code.

5. Enhanced decoupling: Dependency injection promotes loose coupling between classes, which can make your application more resilient to change and easier to test.

IEnumerable and IQueryable interfaces are both used to work with collections of data and both support LINQ (Language Integrated Query).

𝐈𝐐𝐮𝐞𝐫𝐲𝐚𝐛𝐥𝐞

✅ IQueryable executes queries on the server side.

✅ It is designed specifically to work with LINQ

✅ It extends IEnumerable, which means it includes all of the functionality of IEnumerable.

✅ It can be more efficient when working with large data

✅ It can be more helpful when you have to apply a lot of filtrations, you can apply all filters on Queryable and when you are done you can convert data to desired collection

𝐈𝐄𝐧𝐮𝐦𝐞𝐫𝐚𝐛𝐥𝐞 ✔️ IEnumerable executes queries on the client side.

✔️ It is generally used to work with in-memory data collections.

Explanation with code ⤵️

It is good practice to move all of your dependency injection work in a separate class instead of filling your Program.cs with all Injections. Here are some benefits of this approach

1. By keeping dependency injections in separate classes, you can better adhere to the principle of separation of concerns. So, your Program.cs is just focusing on configuration and its DI class headache to manage dependencies.

2. Keeping dependency injections in separate classes can make it easier to maintain the application over time. For any change in DI’s, you would not be changing the Program.cs rather you would just change the desired dependency injection class

3. For better understanding we can create different DI classes that would be dealing with similar dependencies.

How you prefer to keep your dependencies? 📝⤵️

Both TypeOf and GetType help you to get the type with a little difference

✅ typeof gets the type from a class while GetType gets type from an object.

✅ The GetType method is used to retrieve the type of an object at runtime, while the typeof operator is used to retrieve the type of an object at compile-time.

I have described one example where typeof can prove helpful , what other situations could be where GetType and typeof can save us 📝⏬

𝐕𝐀𝐑 ✅ VAR is early binded (statically checked)

✅ It looks at your right-hand side data and then during compile time it decides the left-hand side data type

✅ Use of var makes your code more readable, simplified and reduces the typing.

𝐃𝐘𝐍𝐀𝐌𝐈𝐂 ✔️ Dynamic is late binded (dynamically evaluated).

✔️ It is used to work on dynamic objects.

✔️ It helps us when we are not sure about the data type of objects, saves us from a lot of data type-oriented checking (because the compiler ignores them).

💭 There is a debate over var or proper type. I would like to hear your opinion, many people say that we should use var instead of proper type, but some say that if you are familiar with type then why would you go for var. 📝⏬

Difference b/w String and StringBuilder

𝐒𝐭𝐫𝐢𝐧𝐠𝐁𝐮𝐢𝐥𝐝𝐞𝐫

1. StringBuilder is mutable

2. StringBuilder will only create one object on heap and every time it would be updated with new value even if you append/insert 1 million values.

𝐒𝐭𝐫𝐢𝐧𝐠

1. String is immutable.

2. Every time when we update data in string it creates a new instance of object. So, if you update value 1K times it will create 1K new instances.

𝐓𝐢𝐦𝐞 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞 𝐨𝐯𝐞𝐫 𝟏𝟎,𝟎𝟎𝟎 𝐢𝐭𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 A good rule of thumb is to use strings when you aren't going to perform operations like(Append/Remove) repetitively, use StringBuilder for vice versa.

I took 10,000 iterations and checked the difference for that see the difference in picture.⏬