Forem: .Net Labs

Design Application using Clean Architecture

.Net Labs — Wed, 08 Jan 2025 10:22:06 +0000

Clean Architecture, introduced by Robert C. Martin (Uncle Bob), aims to create systems that are:

Independent of frameworks
Testable
Independent of UI
Independent of database
Independent of any external agency
Clean Architecture emphasizes separating the concerns of different parts of the system and ensuring that each part has a clear responsibility.
.NET clean architecture as a development approach, available in a layered form to reduce dependency.
The architecture consists of several layers, each with a specific role and dependencies that flow in one direction: from the outer layers to the inner layers.

Inner most Layer is independent to its outer layer, means inner most layer does not have any references, it builds and stand independently.

Dependency Rule

The core principle of Clean Architecture is the Dependency Rule, which states that source code dependencies can only point inward. This means:
Nothing in inner circle can depend on anything in an outer circle.
Data formats and structures should also follow this rule.
Infrastructure Layer and Presentation Layer are outer most layer so these two layers does not depend on each other.

The main four layers of clean architecture consist of below layers:

Domain Layer
Application Layer
Infrastructure Layer
Presentation Layer

I have created project for better understanding, let’s Learn in detail.

I have created below Diagram for better understanding.

Key Points

a. Database implementation happens on Infrastructure layer so consider we connected to SQL database and tomorrow if requirement changes then and client says we need to change database to oracle then we can do with impacting other part of application

b. Similarly, Presentation Layer, today in this example we have used api end point and instead of it we want to use ASP.net MVC or any other UI framework we can use it without impacting rest of application.

Please click here to see complete tutorial

Best practice for Reading Configuration in .Net Core

.Net Labs — Wed, 08 Jan 2025 08:31:24 +0000

Every application start with some configurations at it is required to load configurations at time of bootstrap of application.

Most of time we provide string values in appsetting and we use directly in application, let’s learn about different ways to Read configurations

Reading using IConfiguration

Consider below appsetings.json.

"ConfigKeySetting": {
   "Key1": "Keyvalue",
   "Key2": "Keyvalu2",
   "Key3": "Keyvalu2"
 }

When we run application we found all configuration already loaded by Microsoft.AspNetCore.Builder.WebApplicationBuilder

We are injecting IConfiguration object and we can read all keys values.

 [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private readonly IConfiguration _configuration;

        public WeatherForecastController(IConfiguration configuration)
        {

            _configuration = configuration;
        }

        [HttpGet(Name = "ReadConnection")]
        public IActionResult Get()
        {
            var key1 = _configuration.GetValue<string>("ConfigKeySetting:Key1");
            var key2 = _configuration.GetValue<string>("ConfigKeySetting:Key2");
            var key3 = _configuration.GetValue<string>("ConfigKeySetting:Key3");

            return Ok(new
            {
                Key1 = key1,
                Key2 = key2,
                Key3 = key3,

            });

        }

When we run application and call API we can see we able to read all keys

Problem with this approach

a. Default Value Handling : Most of time we put all keys into Azure keyvalue and read from there most of time devops person manages all key vaults so in case my mistake if any key get replaced by devops team then application will break because we do not have any default values if key not found.

We can handle this situation with Options Pattern

b. Real Time Read: Most of time we put all keys into Azure keyvalue and read from there most of time devops person manages all key vaults so in case if we update anything from there then it will not possible to get updated keys without restarting application because everything loaded.

We can read on real time using Options Pattern

b.** No Validation**: IConfiguration does not perform any validation over the configuration values, which might be fatal during the application runtime.

d.** No Type-Safety:** As mentioned earlier, the interface reads configurations as strings that have to be parsed manually. This also increases the chances of configuration-related issues.

**IConfiguration **is a simple and lightweight approach for loading configurations in ASP.NET Core applications from the appsettings file. However, we need a more robust solution for handling a bit more advanced requirements like Validations, Type-Safety, and Reloading etc

Let's learn about Option pattern

Option Pattern

Options Pattern is used to bind a section of configuration settings to the strongly types options classes and add it to the Asp.Net Core Dependency Injection Service Container as singleton lifetime.

Please click here to see complete tutorial

Static Lambda in C# 12 : Performance Improvement

.Net Labs — Tue, 07 Jan 2025 10:02:57 +0000

A Static lambda, introduced in C# 12, is a lambda expression that cannot capture any variables from its enclosing scope. This means no closure class is generated, resulting in less memory allocation and potentially better performance.

Let’s work with some examples.

1. Sorting Collections:

Sorting a list of integers using a static lambda ensures no closures are created, reducing overhead during sorting

var numbers = new List<int> { 53, 31, 8, 1, 2,100,34,55,11,1 };
numbers.Sort(static (a, b) => a.CompareTo(b));
foreach (var item in numbers)
{
    Console.WriteLine(item);
}
Console.ReadKey();

Result

2. Array Filtering
Filtering an array with a static lambda avoids capturing variables, making the filtering operation more efficient.

Console.WriteLine("--------Array Filtering-----------");
var array = new[] { 1, 2, 3, 4, 5 };
var filtered = Array.FindAll(array, static n => n > 3);
foreach (var item in filtered)
{
    Console.WriteLine(item);
}

click here to see complete tutorial

Builder Pattern in C#: Practical Implementation and Examples

.Net Labs — Tue, 07 Jan 2025 09:59:04 +0000

This pattern can be ideal approach to create complex objects

The Builder pattern is a creational design pattern that is used to construct complex objects step by step. It allows you to create different representations of an object using the same construction process.

Let’s first understand the problems that exist without using this pattern.

Complex Constructor with Many Parameters

When creating objects that require many parameters, constructors can become lengthy and hard to read.

public class House
{
    public House(int walls, int doors, int windows, bool hasGarage, bool hasSwimmingPool, bool hasStatues, bool hasGarden)
    {
        // Initialization
    }
}

There are many problems if constructor have too many parameters

i) Each time we need to pass n numbers of parameters at time of object creations

ii) we need to update constructor if we need to pass one more parameter so such constructor difficult to manage

Constructor Overload Explosion

Sometimes we need to create overloaded constructor based on parameters, so managing multiple constructors again have some headache.

To handle different combinations of parameters, multiple constructor overloads are often created, leading to code duplication and increased maintenance.

public House(int walls, int doors) { ... }
public House(int walls, int doors, int windows) { ... }
public House(int walls, int doors, int windows, bool hasGarage) { ... }

3. Readability and Maintainability Issues:

Code that creates instances with many parameters becomes hard to read and maintain.

var house = new House(4, 2, 6, true, false, true, true);

Introduction of Builder pattern to fix those issues
The Builder pattern breaks down the construction of a complex object into simpler steps. Each step builds a part of the product, and the final step assembles the product.

Builder Pattern
Click here to see complete tutorial

Dapper vs EF Core: Understanding When to Use Each

.Net Labs — Tue, 07 Jan 2025 09:53:24 +0000

While designing application we need to understand which we should use and what are use cases, it is very critical to decide based on nature of requirements

Both Dapper and Entity Framework Core (EF Core) are popular Object-Relational Mapping (ORM) libraries for .NET, but they serve different purposes and have distinct strengths.

Dapper

Dapper is a micro ORM that focuses on high performance and simplicity. It maps the results of SQL queries to C# objects, but unlike EF Core, it does not provide advanced features such as change tracking or LINQ-based querying.

Key points

Performance: Dapper is known for its speed. It’s a lightweight library that doesn’t add much overhead, making it great for performance-critical applications where raw speed matters.

Control: Dapper gives you direct control over your SQL queries, making it easier for developers to optimize them for specific database scenarios.

Code Examples

public async Task<Account> GetAccountAsync(Guid accountId)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            var sql = "SELECT * FROM Accounts WHERE AccountId = @AccountId";
            return await connection.QuerySingleOrDefaultAsync<Account>(sql, new { AccountId = accountId });
        }
    }

Real-World Use Cases for Dapper:

1. High-Performance Data Retrieval: If your application needs to handle high-throughput operations, such as querying large datasets or making many database calls, Dapper’s minimal overhead and speed would be ideal.

Example: Real-time analytics applications that need to query and process large volumes of data in real time, such as financial dashboards or e-commerce websites with heavy traffic.

2. Read-Only Operations: When your application only needs to fetch data without performing complex operations, Dapper excels.

Example: Building APIs for querying a public catalog (e.g., an online store’s product catalog) where the focus is on retrieving data without the need for full CRUD operations.

3.Complex SQL Queries: When your queries are too complex for LINQ or require very fine-tuned SQL (e.g., custom joins, aggregations), Dapper allows you to write the SQL exactly as needed.

Example: Reporting services that need to execute complex SQL queries involving joins, window functions, or other advanced SQL features that EF Core may not easily support.

Click here to see complete tutorial

Improve Application Performance using “Fire and Forget” in .NET Core

.Net Labs — Mon, 30 Dec 2024 17:28:27 +0000

Fire and Forget is nothing but it is Executing Task in Background

Deep dive into Task.Run()

By using the fire-and-forget approach appropriately, you can improve the responsiveness and performance of your .NET Core applications while ensuring that important background tasks are performed efficiently.

In this tutorial we will focus on Task.Run and will learn how we can perform background work with Task.Run

What is Task.Run ?

Task.Run queues the specified work to run on the thread pool and returns a Task object representing that work. This allows the work to be performed asynchronously without blocking the main thread.

How Task.Run Works: Control Flow Diagram

Task Creation: The Task.Run method creates a new Task object.
Queueing Work: The task is queued to the thread pool.
Thread Pool Execution: A thread pool thread picks up the task and executes it.

Task Completion: The task completes and the Task object is marked as completed, faulted, or canceled, depending on the outcome.

Task.Run in .NET Core allows you to offload work to a background thread, which can help improve the responsiveness of your application by freeing up the main thread for other tasks

Below is few Real time use cases where we can use Task.Run

Real Time Examples

Logging
This is perfect use case and each and every application doing logging Let’s understand how we can improve performance

Suppose after successful database operation we want to log operation results and if we do sequentially then UI will remain block and OfCourse this is not important work from UI user or client, so if we perform Logging in background then that will increase response time.

Detailed implementation

Logger Service: we are logging using Task.Run in code below

public interface ILoggingService
{
    void LogInformation(string message);
}

public class LoggingService : ILoggingService
{
    public void LogInformation(string message)
    {
        Task.Run(() => 
        {
            // Simulate logging operation
            System.IO.File.AppendAllText("log.txt", $"{DateTime.UtcNow}: {message}{Environment.NewLine}");
        });
    }
}

Controller

[ApiController]
[Route("[controller]")]
public class ExampleController : ControllerBase
{
    private readonly ILoggingService _loggingService;

    public ExampleController(ILoggingService loggingService)
    {
        _loggingService = loggingService;
    }

    [HttpGet]
    public IActionResult Get()
    {  
         // Reading Work to DB

        ///

        _loggingService.LogInformation("Get method called.");
        return Ok("Hello, world!");
    }
}

2. Generating Reports

Please click here to see complete tutorial

Best practice with CancellationToken in .Net Core

.Net Labs — Mon, 30 Dec 2024 17:21:28 +0000

In this tutorial we will lean about CancellationToken and how we can use it.

In earlier days, when we had time taking operations like time consuming DB calls, time consuming HTTP calls we had no option to cancel it.

Using a CancellationToken in your applications provides several benefits, particularly in improving responsiveness, resource management, and user experience. Here are some key advantages:

1. Improved Responsiveness
User Experience: Applications that can cancel long-running tasks quickly respond to user actions, such as canceling a file upload or download, leading to a better user experience.
Real-Time Adjustments: Users can adjust their actions (e.g., stopping a search operation) without waiting for the current operation to complete.

2. Resource Management
Efficient Use of Resources: Canceling unnecessary operations prevents waste of CPU, memory, and other resources. This is particularly important for server-side applications where resources are shared among many users.
Database Connections: In database operations, using CancellationToken can free up database connections that would otherwise be held by long-running queries.

3. Scalability
Handling High Load: Applications can handle high loads more gracefully by canceling operations that are no longer needed, thus freeing up resources for new incoming requests.
Concurrency Control: Effective cancellation helps manage concurrent tasks, ensuring that resources are allocated to the most critical operations.

4. Error Handling and Stability
Graceful Shutdown: When an application needs to shut down or restart, CancellationToken allows for a graceful termination of ongoing operations, reducing the risk of data corruption or inconsistent states.
Preventing Deadlocks: By canceling operations that are taking too long, you can reduce the likelihood of deadlocks and other concurrency issues.

5. Timeout Implementation
Automatic Timeout: Implementing timeouts using CancellationTokenSource.CancelAfter can automatically cancel tasks that exceed a specified duration, ensuring that your application remains responsive.

6. Task Coordination
Cooperative Cancellation: CancellationToken allows for cooperative cancellation, where the operation periodically checks the token to see if cancellation is requested, allowing the operation to clean up and terminate gracefully.
Linked Cancellation Tokens: You can link multiple CancellationTokenSource instances together to cancel multiple operations simultaneously, simplifying the coordination of complex tasks.

7. Simplified Code Maintenance
Standard Pattern: Using CancellationToken establishes a standard pattern for task cancellation, making the code easier to understand and maintain.
Consistent Handling: It provides a consistent way to handle cancellations across different parts of your application, from user-initiated cancellations to automatic timeouts and application shutdowns.

Example Use Cases

Web Applications: Cancel database queries, file uploads/downloads, and API calls that are no longer needed.

Desktop Applications: Allow users to cancel long-running operations like image processing or data analysis.

Mobile Applications: Improve battery life by canceling background operations when they are no longer needed.

Cloud Services: Efficiently manage resources by canceling operations in response to scaling events or maintenance windows.

Here’s a simplified example of how CancellationToken can be used to cancel an ongoing operation:

public async Task LongRunningOperationAsync(CancellationToken cancellationToken)
{
    for (int i = 0; i < 100; i++)
    {
        // Periodically check if cancellation is requested
        cancellationToken.ThrowIfCancellationRequested();

        // Simulate some work
        await Task.Delay(100);
    }
}

public async Task MainAsync()
{
    using var cts = new CancellationTokenSource();

    // Cancel the operation after 2 seconds
    cts.CancelAfter(TimeSpan.FromSeconds(2));

    try
    {
        await LongRunningOperationAsync(cts.Token);
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("Operation was canceled.");
    }
}

Follow this link to see complete tutorial

How to use Scoped service from Singleton Service in .Net Core

.Net Labs — Mon, 30 Dec 2024 15:00:20 +0000

We should be very careful about lifetime of objects in .net core.

Suppose we created Two services one register as Singleton and other as Scoped.

Code

public interface IScopedService
 {  
 }

 public interface ISingletonService
 {

 }

/// Scope service
 public class ScopedService : IScopedService
 {
     public ScopedService()

     {

     }

 }
/// Singelton Service , here we are injecting scope service object
 public class SingletonService : ISingletonService
 {
     public SingletonService(IScopedService svc)

     {

     }

 }

Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();


builder.Services.AddSingleton<ISingletonService, SingletonService>();

builder.Services.AddScoped<IScopedService, ScopedService>();

Understanding of code.

we have created two classes Singelton and Scoped and we have injected scoped inside singleton service.

When we run application, we will get below error

Understanding Error

We have 3 types of service lifetimes:

Singleton — they’re created first time they’re request, and every time after that the same instance will be reused
Scoped — they’re created once per the request (connection)
Transient are created every time you request them from the DI container

_Here we are trying to inject a object that will be created on each user scope request so that required to dispose after each and every request. Here Singelton object will never be going to dispose but scoped object is required to dispose, so this is conflict.
_

As per above explanation we should almost never consume scoped service or transient service from a singleton. You should also avoid consuming transient service from a scoped service.

What is happening when you consume scoped service from a singleton service is known as a captive dependency. It occurs when a service intended to live for a short(er) amount of time gets held by a service that lives for a more extended amount of time. This almost always suggests that you should change something in your design.

*Solution *

If there is need to use Scoped service inside singleton then we need to create scope manually. A new scope can be created by injecting an IServiceScopeFactory into your singleton service. The IServiceScopeFactory has a CreateScope method, which is used for creating new scope instances. IServiceScopeFactory is singelton in itself that’s why it works here.

Please Click here for complete implementation

Fallback Pattern in .NET Core: Handling Service Failures Gracefully

.Net Labs — Mon, 30 Dec 2024 14:50:51 +0000

Fallback pattern is a resilience design pattern

This pattern ensures that alternative response will reach to client even in case of failing primary API.

The Fallback pattern is a resilience design pattern used to provide an alternative or backup solution when the primary service or component fails. It helps ensure that the application continues to function and provide some level of service, even if certain parts are not working as expected.

It ensures service continuity, improves user experience, and provides significant business benefits by reducing the impact of failures.

Problems Resolved by the Fallback Pattern

Continuity of Operations: Ensures critical operations are not interrupted by providing alternative paths for execution.
Service Unavailability: When a primary service is down or unavailable, the fallback pattern provides an alternative, ensuring that the application continues to function.
Error Handling: It allows the system to handle errors gracefully without crashing, maintaining a smooth user experience.
Enhanced User Experience: Minimizes disruptions for end-users, maintaining their trust and satisfaction.

Implementation

Steps
a. We will create 2 Endpoints Primary and Secondary API

b. Primary API will throw error

c. We will implement Fallback Policy into separate Api end point, or we can also create console application client

d. To implement Fallback we will use polly nuget package and we will configure both end point and will define policy like if API 1 not responding then Request go to API 2 and will respond

Click here for code implementation

Fixing Multiple If-Else problem with Chain of Responsibility Pattern

.Net Labs — Mon, 30 Dec 2024 14:43:10 +0000

Situation will become unmanageable if we have lot of if else condition in our code, Lets understand problem and then we will see it’s Solution.

Problem with Multiple If Conditions
Using multiple if-else conditions to handle different cases can lead to code that is hard to read, maintain, and extend. Here’s a simple example using multiple if conditions in a leave management system.

We will implement below Business Logic for Leave management system

a. IF Leave < = 3, then Team Lead will approve

b. IF Leave < =5, then Project Manager will approve

c. IF Leave > 5, then HR Manager will approve

Request first go to team lead to check if Request can be handled by Team lead else it will go to Project Manager else request will go to HR manager

Example with Multiple If Conditions

public class LeaveRequest
{
    public string EmployeeName { get; set; }
    public int NumberOfDays { get; set; }
    public string Reason { get; set; }
}

public class LeaveApprovalService
{
    public void ApproveLeave(LeaveRequest request)
    {
        if (request.NumberOfDays <= 3)
        {
            Console.WriteLine($"Leave request by {request.EmployeeName} for {request.NumberOfDays} days approved by Team Lead.");
        }
        else if (request.NumberOfDays <= 5)
        {
            Console.WriteLine($"Leave request by {request.EmployeeName} for {request.NumberOfDays} days approved by Project Manager.");
        }
        else if (request.NumberOfDays > 5)
        {
            Console.WriteLine($"Leave request by {request.EmployeeName} for {request.NumberOfDays} days approved by HR Manager.");
        }
        else
        {
            Console.WriteLine("Leave request could not be processed.");
        }
    }
}

Problems in above code

Maintainability: The method becomes harder to maintain as the logic grows.

Single Responsibility Principle (SRP): The method does too much by handling all approval levels, violating the single responsibility principle.

*Testing * : Each time we add new condition we need to test end to end to make sure nothing is breaking because we are making changes into existing class because we are breaking SRP.

Solution with Chain of Responsibility Pattern

Please click here for fixing this problem

Optimizing Performance using Efficient LINQ queries

.Net Labs — Sun, 29 Dec 2024 11:48:18 +0000

In efficient SQL or LINQ may results into poor performance because that will lead high cost of reading data and will consume more resources. High consumption of CPU may lead to poor application response and server will not able to serve whatever server can deliver.

Using Any Instead of Count for Existence Check Problem: Count iterates over the entire collection to count elements.

Example:

// BAD code
bool exists = collection.Count(x => x.IsActive) > 0;

//Efficient Code
bool exists = collection.Any(x => x.IsActive);

Explanation: Any stops after finding the first matching element, improving performance

Avoiding ForEach with LINQ Problem: ForEach requires you to materialize the collection (using ToList() or ToArray()), which can have performance implications, especially with large datasets.

Consequence: By forcing materialization, you lose the advantages of lazy evaluation in LINQ, leading to unnecessary intermediate collections being created, which can impact performance and memory usage.

Poor Code:

var result = numbers.Where(n => n > 2).ToList().ForEach(n => Console.WriteLine(n)); // Forces enumeration, breaking lazy evaluation

Effificent Code

var result = numbers.Where(n => n > 2).ToList();  // Materializing to a list, then using ForEach
result.ForEach(n => Console.WriteLine(n));

Explanation: Use a foreach loop for side effects to avoid unnecessary list creation.

3.Efficient Distinct Usage
Problem: Using Distinct on large datasets can be slow.

//bad one
var result = collection.Select(x => x.Name).Distinct().ToList();


//Efficient code
var result = collection.Select(x => x.Name).ToHashSet();

In LINQ, both ToHashSet() and Distinct() are used to eliminate duplicates from a collection, but they differ in how they operate internally, which affects performance.

ToHashSet() and Distinct() Comparison
**
**1. ToHashSet()

Description: Converts a collection into a HashSet, which automatically removes duplicates because HashSet is a collection that only allows unique elements.

Performance: ToHashSet() is typically faster when removing duplicates because it uses the hashing mechanism to check for uniqueness while building the set. The time complexity is generally O(n), where n is the number of elements in the collection. This is because HashSet has an average time complexity of O(1) for insertion and membership checks.

2. Distinct()

Description: Distinct() is a LINQ method that removes duplicates from a collection by comparing the elements using their default equality comparer (or a custom one if provided). It returns a new collection (typically an IEnumerable).

Performance: Distinct() internally uses a HashSet as well, but since it works on IEnumerable, it has a higher overhead due to the deferred execution and the need to iterate through the collection. The time complexity is also generally O(n), but it can have higher overhead because it requires creating an enumerator and possibly comparing each item in the sequence.

Conclusion:

Use ToHashSet() when you just need to remove duplicates and are working directly with a collection.

Use Distinct() if you're working in the context of a LINQ query with more complex operations.

Please Read complete list with below Url

Follow this link to know more about performance with Linq

Understanding Network Latency for High performance web-based applications

.Net Labs — Sun, 29 Dec 2024 11:23:52 +0000

It is crucial to consider Latency for High performance web-based applications

Network latency is the time it takes for data or a request to go from the source to the destination. Latency in networks is measured in milliseconds.

High latency can significantly affect the performance of networked applications, causing delays and reducing the overall user experience.

Symptoms of Network Latency

Slow Response Times: Web application will take longer time to load
Timed-out Connections: Connections to servers may time out due to delays in data transmission.
High Ping Times: Measured in milliseconds (ms), high ping times indicate delays in communication between devices.

Root Causes of Network Latency

1.** Physical Distance:**
Suppose we have application hosted at United state and all users of applications belongs to Australia. In this case data packets are travelling too much distance which does not make sense here.

In above example we can see it has high latency due to packet travel too long due to huge physical distance between server and user so we should choose correct server location based on real time usage.

Here in example below we can see Server and user both are in same country then we will have less latency issues due to less physical distance

Network Congestion: High traffic on the network can cause delays as data packets compete for bandwidth
Routing and Hops: Data passing through multiple routers and switches (hops) can slow down transmission.

In this diagram we can see latency will increase due to lot of routers in network path.

4.** Hardware Limitations**: Outdated or insufficient hardware (e.g., routers, switches) can contribute to latency.

5.** Network Protocols and Configuration**: Inefficient network protocols or misconfigured network settings can introduce delays.

Server Load: Overloaded servers can slow down response times, adding to latency.

We have multiple Solutions for this so let's discuss

Please Click here to get solutions