.NET provides several ways to build APIs, including MVC Controllers and Minimal APIs. As projects grow, Minimal APIs can get messy, and MVC often leads to unnecessary boilerplate. FastEndpoints solves these issues by offering a clean, vertical-slice approach called REPR (Request–Endpoint–Response) while delivering excellent performance.

What is REPR (Request – Endpoint – Response)?

The REPR pattern is at the heart of FastEndpoints. Here’s how it works, step by step:

1. Request – Define what data comes in (like an ID, name, or any user input).
2. Endpoint – Write what your API does with that data. This is where your business logic lives.
3. Response – Specify what data goes back to the user (such as details about an item or a status message).

Every API feature in your project uses these three parts, making the code tidy, testable, and easy to understand—even for beginners.

Performance & Developer Experience

FastEndpoints delivers performance on par with Minimal APIs and is significantly faster than MVC Controllers—benchmarks show around 35k more requests per second than MVC.

Besides speed, FastEndpoints encourages maintainability, self-contained endpoints, less boilerplate, and easier code organization. This all leads to a better experience for developers at every level.

How to Set Up FastEndpoints

Setting up FastEndpoints is quick and simple. Follow these basic steps:

1. Add the FastEndpoints NuGet package

dotnet add package FastEndpoints

2. Register FastEndpoints in your app In Program.cs, add:

builder.Services.AddFastEndpoints();
app.UseFastEndpoints();

3. (Optional) Set a global route prefix To use api as the prefix for all endpoints:

app.UseFastEndpoints(c => c.Endpoints.RoutePrefix = "api");

That’s it; your project is ready for FastEndpoints! Now you can start adding endpoints using the REPR pattern.

Creating a Simple Endpoint

With FastEndpoints, you define each API endpoint as its own class that inherits from the Endpoint base class. Here’s a simple example that shows how to handle HTTP GET requests for fetching a customer by ID

public class GetCustomerByIdRequest
{
    public int CustomerId { get; set; }
}

public class GetCustomerByIdResponse
{
    public int CustomerId { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

public class GetCustomerByIdEndpoint : Endpoint<GetCustomerByIdRequest, GetCustomerByIdResponse>
{
    public override void Configure()
    {
        Get("api/customers/{CustomerId}");
        AllowAnonymous();
    }

    public override async Task HandleAsync(GetCustomerByIdRequest req, CancellationToken ct)
    {
        var customer = new GetCustomerByIdResponse
        {
            CustomerId = req.CustomerId,
            Name = "Jane Doe",
            Email = "jane.doe@example.com"
        };

        await SendAsync(customer);
    }
}

How it works:

• GetCustomerByIdRequest: Describes what data comes in (CustomerId).
• GetCustomerByIdResponse: Describes what data goes out (customer info).
• GetCustomerByIdEndpoint: Defines the route, accepts the request, processes it, and sends back the response—all in one place.

A closer look at the key methods

Configure()

• This method sets up your endpoint. Here you define the HTTP method (like GET), the route (URL), and any settings such as whether login is needed.

Example:

public override void Configure()
{
    Get("api/customers/{CustomerId}");
    AllowAnonymous();
}

This sets up a GET endpoint at /api/customers/{CustomerId} that does not require login.

HandleAsync()

• This is where your main logic lives. It runs every time someone makes a request to your endpoint. You use it to process the request, fetch or update data, and prepare the response.

SendAsync()

Use this inside HandleAsync() to send the response back to the user.

await SendAsync(customer);

This sends the customer info as the response.

Endpoint<GetCustomerByIdRequest, GetCustomerByIdResponse>

• This means the class acts like a mini API that takes a GetCustomerByIdRequest (input from the user) and gives back a GetCustomerByIdResponse (the output/result).

This demonstrates the power of REPR: clear, self-contained code for each API feature.

Further developments - Best Practices

• Strongly typed DTOs: Define clear Request and Response classes for every endpoint.
• Vertical-slice organization: Keep each endpoint in its own file or folder for better maintainability.
• Global route prefix: Use app.UseFastEndpoints(c => c.Endpoints.RoutePrefix = "api") for a clean API structure.
• Validation: Integrate FluentValidation for automatic model checks.
• Processors: Use IPreProcessor<T> and IPostProcessor<T> for cross-cutting concerns like logging and caching.
• Security: Apply JWT, cookie authentication, or custom schemes; use AllowAnonymous(), Roles(), or Scopes() per endpoint as needed.

Demp Project

GitHub - csandun/PoC1_FastEndpoint

Contribute to csandun/PoC1_FastEndpoint development by creating an account on GitHub.

GitHubcsandun

Resources

1. FastEndpoints Doc
2. FastEndpoints Github
3. REPR Design Pattern

To begin our series, we'll start by mind mapping the Azure App Service module, laying the foundation for our journey.

Azure App Service Intro

Azure App Service is a powerful cloud platform from Microsoft that lets you easily create web apps and APIs. To start our series, we're going to create a mind map for the Azure App Service module. This will give us a clear, visual overview of its key features, how to deploy apps, and how to manage them effectively.

Azure App Service Mind Map

Let's explore Azure App Service as part of the AZ-204 certification, guided by a detailed mind map. This visual representation will help us dissect and understand the service's key features and functionalities, making complex concepts accessible and straightforward.

1. Azure App Service

A Mind Map about 1. Azure App Service submitted by ZvFejbBFFA on Mar 8, 2024. Created with Xmind.

XmindXmind Ltd.

Shareable Mind Map

Using the provided mind map, we'll dive deeper into Azure App Service in our upcoming discussions. This tool will not only enhance our exploration but also serve as a valuable resource in your preparation for the AZ-204 certification. Stay tuned for our next post, where we'll continue unraveling the intricacies of Azure App Service together.

In my current job, I was tasked with developing a large-scale approval process for a complex system. To demonstrate the feasibility and benefits of using a StateMachine for this purpose, I created a Proof of Concept (POC). Due to confidentiality reasons, I cannot reveal the specifics of my company's process. However, I can describe the approach and benefits using a code review approval process as an example. In this two-part blog post series, I will first discuss the approach of this type of requirement,  then the benefits of using a state machine for managing approval processes and illustrate the process using PlantUML diagrams. In the second part, we will implement the State Machine-based code review approval process in C#.

Requirement: The code review (PR) approval process

As a software development team, we require a streamlined and effective approach to handling the code review approval process, which encompasses stages such as open, approved, rejected, merged, and closed. The solution should be user-friendly and maintainable, as well as facilitate the addition or modification of states and transitions in the future. Moreover, we're utilizing the Azure DevOps approval process for pull requests.

Advantages of Using State Machine

Managing the code review approval process can be approached in various ways, such as using if-else statements, switch statements, or custom logic. However, these methods can become complex and hard to maintain as the number of states and transitions grows. State machines offer numerous benefits over these techniques:

• Distinct separation of states and transitions: State machines deliver a clear and organized framework to define and handle states and transitions, resulting in more comprehensible code.
• Scalability: State machines simplify the process of adding or modifying states and transitions, enabling easy scalability and maintainability.
• Reduced complexity: State machines abstract the logic for state transitions, decreasing code complexity and making testing and debugging more accessible.
  

Why we do not use so much If-Else

Consider a simple code review approval process using if-else statements. While it might work for a few states, it can quickly become complex and difficult to maintain as the number of states and transitions increases. Here's an example:

public void ProcessPullRequest(string action)
{
    if (CurrentState == "Open")
    {
        if (action == "Approve")
        {
            CurrentState = "Approved";
        }
        else if (action == "Reject")
        {
            CurrentState = "Rejected";
        }
        else if (action == "Close")
        {
            CurrentState = "Closed";
        }
    }
    else if (CurrentState == "Approved")
    {
        if (action == "Complete")
        {
            CurrentState = "Completed";
        }
    }
    else if (CurrentState == "Rejected")
    {
        if (action == "Resubmit")
        {
            CurrentState = "Open";
        }
        else if (action == "Close")
        {
            CurrentState = "Closed";
        }
    }
}

In this example, we're using  to handle the transitions between states in the code review approval process. As the process becomes more complex with additional states and transitions, the nested if-else statements will become increasingly difficult to manage, understand, and maintain.

Identifying States and  Transitions

The code review approval process consists of various states and transitions that help manage the lifecycle of a Pull Request (PR).

Here's a brief overview of the states and transitions in the approval process:

States:

1. Open: The PR is submitted and awaits review.
2. Approved: The PR has been reviewed and meets the required standards.
3. Rejected: The PR does not meet the required standards and needs revisions.
4. Completed: The PR has been approved and integrated into the codebase.
5. Closed: The PR is no longer needed or further revisions won't be made.

Transitions:

1. Submit PR: A developer submits a PR, transitioning it from a non-existent state to the "Open" state.
2. Approve: A reviewer approves the PR, transitioning it from the "Open" state to the "Approved" state.
3. Reject: A reviewer rejects the PR, transitioning it from the "Open" state to the "Rejected" state.
4. Revise and resubmit: The developer makes revisions and resubmits the PR, transitioning it from the "Rejected" state back to the "Open" state.
5. Complete : The PR is merged into the target branch, transitioning it from the "Approved" state to the "Completed" state.
6. Close: The PR is closed without merging, transitioning it from the "Open" or "Rejected" state to the "Closed" state.

These states and transitions form the backbone of the code review approval process, allowing teams to effectively manage PRs and ensure a smooth and efficient workflow.

Visualizing the Process with PlantUML

Before diving into the code implementation, it's helpful to visualize the approval process using PlantUML. By creating a state diagram with PlantUML, we can clearly represent the states and transitions in the code review approval process.

@startuml

hide empty description
title Code Review Approval Process

state "Open" as open
state "Approved" as approved
state "Rejected" as rejected
state "Completed" as completed
state "Closed" as closed

[*] --> open : SubmitPR()
note right of open : Awaiting review
open --> approved : Approve()
note right of approved : Meets standards
open --> rejected : Reject()
note left of rejected : Needs revisions
rejected --> open : Revise&resubmit()
approved --> completed : Complete()
note right of completed : Integrated into codebase
open --> closed : Close()
rejected --> closed : Close()
note left of closed : No further revisions
completed --> [*]
closed --> [*]

@enduml

Lets see generated process State Machine Image

Copy this PlantUML code and paste it into an online PlantUML editor such as PlantText or PlantUML Online Editor to generate a visual diagram of the code review approval process. This diagram illustrates the various states and transitions in the process, providing a clear understanding of the process.

Resources

1. Modelling Workflows With Finite State Machines in .NET
2. State Machine Workflows
3. State Machine and State Design Pattern

Hi developers! Want to improve your .NET Core projects while keeping your code clean? You're in luck! Today, we'll explore MediatR and its Notification feature through a practical use case, showing how it can elevate your applications. Let's dive in!

What is MediatR

If you're new to MediatR, it's an open-source library that helps you implement the popular Mediator pattern in your .NET Core projects. MediatR acts as a central communication hub, allowing different parts of your application to talk to each other without direct dependencies. Say goodbye to tightly-coupled code and hello to cleaner, more maintainable projects.

MediatR Notifications

MediatR's Notification feature, also known as Publish, enables you to broadcast messages to multiple handlers asynchronously. This powerful mechanism informs your application's components about important events or changes without complicated logic or cumbersome wiring. It's like having your news network within your project!

Use Case:

Notify Email and SMS to Customers after Order Creation Event:

Imagine you're building an e-commerce application and need to notify customers via Email and SMS when their orders are created. Using MediatR Notifications, you can elegantly achieve this.

Explanation

In modern applications, executing tasks like sending emails or SMS notifications asynchronously ensures a smooth user experience and prevents unnecessary delays. For example, when creating an order, the primary focus should be completing the order process without depending on immediate responses from email or SMS services.

Leveraging MediatR Notifications allows efficient management of these asynchronous tasks, enabling the independent progression of the order creation process. This approach ensures application responsiveness and optimal performance while sending email and SMS notifications in the background without impacting the primary functionality of the order creation handler.

However, a single request can be handled by Multiple handlers. Some independent operation needs to occur after some events.

Practical

Explore my GitHub-linked codebase, where I've implemented the CQRS pattern using the MediatR library. Featuring a clean architecture within a single project structure, I've elegantly crafted an Order Create Command and corresponding Command Handler for the use case mentioned above.

1. First of all, Let’s create a notification and handler.  It is also referred to as events. Add a class with the name `OrderCreatedNotification`.

public class OrderCreatedNotification : INotification
{
    public Order Order { get; set; }
}

2. Now, I have created two handlers, one for sending Email and one for SMS.

public class OrderCreatedEmailHandler : INotificationHandler<OrderCreatedNotification>
{
    private readonly ILogger<OrderCreatedEmailHandler> _logger;

    public OrderCreatedEmailHandler(ILogger<OrderCreatedEmailHandler> logger)
    {
        _logger = logger;
    }

    public Task Handle(OrderCreatedNotification notification, CancellationToken cancellationToken)
    {
        // Send a confirmation email
        _logger.LogInformation($"Confirmation email sent for order {notification.Order.Id}");

        return Task.CompletedTask;
    }
}

public class OrderCreatedSMSHandler : INotificationHandler<OrderCreatedNotification>
{
    private readonly ILogger<OrderCreatedSMSHandler> _logger;

    public OrderCreatedSMSHandler(ILogger<OrderCreatedSMSHandler> logger)
    {
        _logger = logger;
    }

    public Task Handle(OrderCreatedNotification notification, CancellationToken cancellationToken)
    {
        // Send a confirmation sms
        _logger.LogInformation($"Confirmation sms sent for order {notification.Order.Id}");

        return Task.CompletedTask;
    }
}

You can elegantly incorporate the relevant logic within handlers, ensuring a clean and maintainable approach to implementing functionality in your application.

Trigger the Notification

Open `CreateOrderCommandHandler` and modify the handler method for publishing the order once saved in the database. Here I am representing a new order, including a new OrderId.

// Publish a notification that the order has been created
await _mediator.Publish(new OrderCreatedNotification() { Order  = order }, cancellationToken);

The notification carries an OrderId property containing the newly created order's ID. Using the _mediator.Publish() method, the notification is asynchronously dispatched to all registered handlers interested in the OrderCreated event.

Output

Swagger representation

Output in terminal

Here we can see logs from both handlers.

Other use cases of MediatR Notifications

1.Event-driven architecture:
MediatR Notifications enable services in an event-driven system to communicate through events, promoting asynchronous reactions and reducing tight coupling.

2.Cross-cutting concerns:
Notifications handle concerns like logging, auditing, or monitoring by using separate handlers for each, ensuring clean separation and easy modification.

3.Integrating with external systems:  
Notifications facilitate integration with external systems like messaging platforms (e.g., RabbitMQ, Kafka) or third-party APIs by processing notifications and sending messages or API requests as needed.

4.Caching and data synchronization:
Notifications maintain consistency and performance in distributed systems by alerting relevant services or components about data changes, triggering cache invalidation or data updates.

Let's discuss these concepts further in upcoming sections. Stay tuned for more insights on effectively incorporating this powerful tool in your .NET Core applications!

Conclusion

MediatR Notifications is a game-changer for your .NET Core projects in microservices architecture, streamlining communication and enhancing maintainability. Implementing this powerful feature can boost your application's capabilities while keeping your codebase clean and efficient.

Resources

1. MediatR repository
2. Why use MediatR? 3 reasons why and 1 reason not
3. Wiki

Demo Project

GitHub - csandun/MediatrWithPublish: This is a sample project demonstrating how to use MediatR INotification to send email notifications

This is a sample project demonstrating how to use MediatR INotification to send email notifications - GitHub - csandun/MediatrWithPublish: This is a sample project demonstrating how to use MediatR ...

GitHubcsandun

In Byte-Sized #3 we are looking about the Intersect() method. Thats finds the common elements between two collections.

What is Intersect()

In LINQ , Intersect() is an operator to perform a set intersection of two sequences. It returns a new sequence that contains the elements common to both sequences, in other words, the elements that appear in both sequences.

The syntax for using the Intersect operator in LINQ is as follows:

var commonElements = sequence1.Intersect(sequence2);

Today I am going to introduce how to play with Intersect and the new syntaxes of this.

Simple sequences

You can use the Intersect operator to find the common elements between the two lists as follows:

List<int> list1 = new List<int> { 1, 2, 3, 4, 5 };
List<int> list2 = new List<int> { 3, 4, 5, 6, 7 };

var list1list2Common = list1.Intersect(list2);

foreach (var item in list1list2Common)
{
    Console.WriteLine(item);
}

/*
3
4
5
*/

The result will be a new sequence containing the elements { 3, 4, 5 }, which are the elements that are common to both lists.

complex object sequences

Suppose you have a class Person that represents a person with a name and an age.

public class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }
}

And I used below List3 and List4 for describe examples

var list3 = new List<Person> 
{ 
    new Person { Name = "Alice", Age = 25 }, 
    new Person { Name = "Bob", Age = 30 }, 
    new Person { Name = "Charlie", Age = 35 },
    new Person { Name = "Eve", Age = 50 }
};

var list4 = new List<Person> 
{ 
    new Person { Name = "Bob", Age = 30 }, 
    new Person { Name = "David", Age = 35 }, 
    new Person { Name = "Eve", Age = 40 }
};

1. Using IEquatable<T>

To use Intersect with complex object lists, you can implement the IEquatable<T> interface on the class that represents the objects in the lists. The IEquatable<T> interface defines the Equals() method, which is used by the Intersect operator to compare the objects in the lists.

public class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    // override Equals method
    public bool Equals(Person other)
    {
        if (other == null) return false;
        return (this.Name == other.Name 
        			&& this.Age == other.Age);
    }
}

//...

var list3list4CommonEquatable = list3.Intersect(list4);

foreach (var item in list3list4CommonEquatable)
{
    Console.WriteLine(item.Name); // Bob
}

Here is the Sample code, and As the Name and Age, Bob is the common element in the sequence.

2. Using IEqualityComparer<T>

You can also use the Intersect operator on complex object lists by providing a custom IEqualityComparer<T> implementation that defines how to compare the objects in the lists.

I have created a custom PersonComparer class that implements the IEqualityComparer<Person> interface. This custom comparer defines how to compare two Person objects by implementing the Equals method, and how to calculate the hash code of a Person object by implementing the GetHashCode method.

public class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null || y == null) return false;
        return (x.Name == y.Name && x.Age == y.Age);
    }

    public int GetHashCode(Person obj)
    {
        if (obj == null) return 0;
        return obj.Name.GetHashCode() 
        			^ obj.Age.GetHashCode();
    }
}

To use the Intersect operator on a list of Person objects, you can create two lists and a new instance of PersonComparer, and then call the Intersect method with the two lists and the custom comparer.

var comparer = new PersonComparer();

var commonPeople = list1.Intersect(list2, comparer);

IntersectBy() - New Implementation

Exisiting method  Intersect has been powered up by these new methods which can take a selector function to operate. This IntersectBy() was introduced with .NET 6 new linq features.

If we simply want to compare elements by key (Name), then we can use IntersectBy instead of creating comparer. Following code generates same output as using comparer.

// in this name is the key
var list3list4CommonSingleProperty 
	        = list3.IntersectBy(
            	list4.Select(o => o.Name), 
                x =>x.Name);

foreach (var item in list3list4CommonSingleProperty)
{
    Console.WriteLine(item.Name);
}

//Bob
//Eve

Here is an example of the showcase of how multiple properties can process like comparer. Here Age and Name are considered equality properties.

var list3list4CommonMultipleProperties 
		= list3
        .IntersectBy(list4.Select(o => new { name = o.Name, age = o.Age}),
         x => new {name = x.Name, age= x.Age});

foreach (var item in list3list4CommonMultipleProperties)
{
    Console.WriteLine(item.Name);
}

Conclusion

Resources

1. Microsoft Documentation
2. LINQ Intersect Method in C#

Demo Project

There is a demo project you can check out over on GitHub with the examples for Intersect() and IntersectBy().

GitHub - csandun/IntersectInLinq

Contribute to csandun/IntersectInLinq development by creating an account on GitHub.

GitHubcsandun

Every commit is important. So let's celebrate each and every commit with a corresponding emoji! 😀

Using emojis in your commit messages will be fun (😊) and cool (😎) in the first place. They can be recognized at a glance, no matter the spoken language. So today, we will look into Git emojis in our short blog post (Byte-Sized #2). Also Currently, many version control websites are supported for Git Emojis.

What is Git Emojis?

Git Emojis are a set of custom emoji symbols used in commit messages or code comments to provide extra context and expression to the changes being made to a codebase. They are usually added along with a commit message to help convey the nature of the changes made in a more visually expressive and fun way.

Benefits we can get from Git emojis

1. Clarity and Conveying Intent: Git emojis help convey the intent behind the changes being made clearly and concisely.
2. Enhanced Visual Representation: Emojis are visually appealing and make it easier for developers to quickly understand the nature of the changes being made to a codebase.
3. Improved Collaboration: Using Git emojis can help enhance collaboration within a development team by creating a shared understanding of the changes and the intent behind them.
4. Increased Engagement and Fun: Using Git emojis can add a touch of fun and personality to the otherwise monotonous task of version control and can help increase developers' engagement and motivation.
5. Improved Codebase Documentation: Using Git emojis can help document a codebase's history and the changes being made, making it easier for new developers to understand the context and intent behind the code.

Example

Git emojis consist of a shortcode representation of an emoji symbol, such as :bug: (🐛) for a bug fix or :sparkles: (✨) for a new feature. They can be added to the beginning or end of a commit message or code comment to indicate the nature of the changes being made.

This is the famous git repository where emojis are used clearly by jasontaylordev. Refer to that commit massages and get a good idea of it.

GitHub - jasontaylordev/CleanArchitecture: Clean Architecture Solution Template for .NET 7

Clean Architecture Solution Template for .NET 7. Contribute to jasontaylordev/CleanArchitecture development by creating an account on GitHub.

GitHubjasontaylordev

My favorite emojis

How we use Git Emojis in your project

Using gitmoji-vscode for VSCode users

gitmoji-vscode is a VSCode extension 📇 that helps you to add emoji right from your editor itself.

You can find gitmoji supported extension for your favorite editor too. 🧑‍💼

You can use git repositories shared by the community.

Git Commit message Emoji

Git Commit message Emoji. GitHub Gist: instantly share code, notes, and snippets.

Gist262588213843476

GitHub - ahmadawais/Emoji-Log: Emoji-Log — An Emoji Git commit log messages spec standard. [ 📦👌🐛📖🚀🤖 ‼️]

Emoji-Log — An Emoji Git commit log messages spec standard. [ 📦👌🐛📖🚀🤖 ‼️] - GitHub - ahmadawais/Emoji-Log: Emoji-Log — An Emoji Git commit log messages spec standard. [ 📦👌🐛📖🚀🤖 ‼️]

GitHubahmadawais

You can use the google chrome extension as well.

Gitmoji Browser Extension

The Gitmoji extension to easily search and copy gitmojis 😜

Chrome Web Store

And apart from these methods, you can just copy-paste emoji from the internet too.

gitmoji

An emoji guide for your commit messages.

An emoji guide for your commit messagesCarlos Cuesta

Conclusion

Using Git emojis is not part of the standard Git specification. Still, it is a common convention used by many development teams to help make their version control workflows more visually appealing and informative. Using Git emojis, developers can quickly and easily understand the intent behind changes to a codebase and make version control a more enjoyable 😁 and engaging experience.

Resources

1. https://gitbetter.substack.com/p/how-to-use-emoji-in-your-commit-message
2. https://wilsonmar.github.io/git-messages/

Happy coding, Happy git commiting 🤡 !!!

Welcome to the "Byte-Sized" blog series

To kick off our series, let's apply Dependency Injection to Asp.net Core Console App.

Byte-Sized 01 Context

In my previous company, we relied heavily on console applications and windows services to automate various tasks and processes. In this context, I applied Dependency Inject into the Console Apps.

I got several benefits: increased flexibility and improved testability, better code reuse, easier maintenance, and improved code organization. Also, it helps to make the application more scalable and maintainable, ultimately resulting in better performance and quality.

How to apply Dependency Injection (DI) in a console application

1. Create dotnet 7 Console App

Create an empty console app using your IDE or dotnet CLI . Here I am using Rider. You can use  blow command in dotnet CLI

dotnet new console

When create a console app, you can see a simple 'Hello world'  application like this.

2. Create a mock service with interface as business logic

Well, Then I create a mock business service called CustomerService. As well ICustomerService. Today we are going to register this service in DI layer.

public interface ICustomerService
{
    public void CalculateCustomerAge(int id);

}

public class CustomerService: ICustomerService
{
    public void CalculateCustomerAge(int id)
    {
        Console.WriteLine("CustomerService:CalculateCustomerAge runs");
    }
}

3. Setup Host

1. Add relevant NuGet packages

Add the Microsoft.Extensions.DependencyInjection NuGet package to your project using dotnet CLI.

dotnet add package Microsoft.Extensions.DependencyInjection --version 7.0.0

Also we want Microsoft.Extensions.Hosting to add hosting and startup infrastructure for the application

dotnet add package Microsoft.Extensions.Hosting --version 7.0.0

2. Put code snippets to create builder and DI layer

In the Main method of the console application, create a new HostBuilder object, and register your concrete implementation with the service collection.

// create hosting object and DI layer
using IHost host = CreateHostBuilder(args).Build();

// create a service scope
using var scope = host.Services.CreateScope();

var services = scope.ServiceProvider;


// add entry point or call service methods
// more .....


// implementatinon of 'CreateHostBuilder' static method and create host object
IHostBuilder CreateHostBuilder(string[] strings)
{
    return Host.CreateDefaultBuilder()
        .ConfigureServices((_, services) =>
        {
            services.AddSingleton<ICustomerService, CustomerService>();
            services.AddSingleton<App>();
        });
}

Here you can register our CustomerService mock service in Dependency layer.

4. Add Entry point to Application

Create a App class as a entry class with Run() entry method.

public class App
{
    private readonly ICustomerService _customerService;
    
    public App(ICustomerService customerService)
    {
        _customerService = customerService;
    }

    public void Run(string[] args)
    {
        _customerService.CalculateCustomerAge(1);
    }
}

You can access console arguments from args string property. Also you should register App class in DI layer

IHostBuilder CreateHostBuilder(string[] strings)
{
    return Host.CreateDefaultBuilder()
        .ConfigureServices((_, services) =>
        {
            services.AddSingleton<ICustomerService, CustomerService>();
            services.AddSingleton<App>(); // -> register App class 
        });
}

In Program.cs we can call Run method as below.

// ....

var services = scope.ServiceProvider;

try
{
    services.GetRequiredService<App>().Run(args);
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
}


//...

Time to run the your first "Hello World" Console application with Depencency Injection.

Full Program Class

using ConsoleAppWithDI;
using ConsoleAppWithDI.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

using IHost host = CreateHostBuilder(args).Build();
using var scope = host.Services.CreateScope();

var services = scope.ServiceProvider;

try
{
    services.GetRequiredService<App>().Run(args);
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
}

IHostBuilder CreateHostBuilder(string[] strings)
{
    return Host.CreateDefaultBuilder()
        .ConfigureServices((_, services) =>
        {
            services.AddSingleton<ICustomerService, CustomerService>();
            services.AddSingleton<App>();
        });
}

Source Code repository

GitHub - csandun/ConsoleAppWithDI

Contribute to csandun/ConsoleAppWithDI development by creating an account on GitHub.

GitHubcsandun

Resources

1. Documentation
2. From Tom Coory | From Youtube

Next Step:

The next step in this blog series can be to add an appsettings.json file and read configuration and add logs in your ASP.NET Core console application under DI framework. Keep in touch this valueable short series.

Today's blog post is about efficient and effective ways to return an empty IEnumerable from a method.  Many developers need to be aware of the different options available.  Still, with the help of some benchmark testing and a deep dive into the appropriate methods, we will clear up any confusion and provide a comprehensive guide.  By the end of this post, you will have a solid understanding of the most efficient ways to return an empty IEnumerable from a method and be equipped to make informed decisions for your projects.

Intro

As per my experience,  there are three common ways to return an empty IEnumerable from a method:

1. new List<T>()

This creates a new instance of an empty List object, which implements the IEnumerable interface.  This method is so straightforward.

2. new List<T>(0)

This creates a new instance of a List object with an initial capacity of 0 (zero). This method is similar to new List ().

3. Enumerable.Empty<T>()

This method returns a singleton instance of an empty IEnumerable object.

Benchmarking

Let's talk about these methods behave in a benchmark test.  According to the results, we can deep-dive into the method's actual implementation.

Let's examine further by benchmarking the performance using Benchmark.Net.  For the tests, let's create the following class.

After benchmarking, I got the below results for memory allocation and execution time.

As you can see, though the StaticEmptyMethod is slightly faster, it also consumes non of the memory.  How does it happen?  It's time to investigate the reasons.

Why new List() bit slow than others

This method is straightforward but can result in unnecessary object creation, affecting performance, especially in situations where the empty collection is returned frequently.  As well, every time it allocates memory for the new List.

Additionally, it creates a list with an initial capacity of 0, but the capacity is automatically resized as elements are added to the list.  This means that the list will be resized multiple times as elements are added, which can affect performance.

Why new List(0) bit efficient than new List()

This method is similar to new List () but provides a more efficient way to create an empty list when you know the final size of the List will be 0.  This means that the list will not need to be resized as elements are added, resulting in more efficient performance.

Why does Enumerable.Empty() show well efficient than others

As you can see here, Empty() is just a static method returning Instance from EmptyEnumerable class…

going bit further....

Oh, look, just a static property of a 0-sized array!  So every time we call Enumerable.Empty<T>(); we get the same array.  So when we call Enumerable.Empty<T>() 100 times; again there will be just 1 array more in the memory instead of 100.  So there is not 100 memory allocations 100 times.  Wow, It is an awasome practice by Microsoft.

Also interesting code commit there:

// We have added some optimization in SZArrayHelper class to cache the enumerator of zero length arrays so
// the enumerator will be created once per type.

Also Enumerable.Empty() added consistency for the code.
Using Enumerable.Empty() makes it clear that the intention is to return an empty collection, rather than a collection with a specific number of elements. This can improve code readability and maintainability.

Also can ensure consistency throughout your codebase and make it easier to maintain a common pattern for creating empty collections.

My Thoughts and Conclusion

In terms of memory usage, ⚡️Enumerable.Empty()⚡️ is more efficient because it returns a reference to a singleton instance of an empty collection, rather than creating a new instance each time it's called. This helps reduce the number of objects created, which can be beneficial in terms of both memory and performance.
Additionally, using Enumerable.Empty() can also improve code readability and maintainability by making it clear that the intention is to return an empty collection, rather than a collection with a specific number of elements.

Resources

1. https://bytelanguage.com/2018/07/27/enumerable-empty-vs-array-initialization-syntax/
2. https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.empty?view=net-7.0 🔥🔥
3. Source code of Enumerable class in Github

referencesource/Enumerable.cs at master · microsoft/referencesource

Source from the Microsoft .NET Reference Source that represent a subset of the .NET Framework - referencesource/Enumerable.cs at master · microsoft/referencesource

GitHubmicrosoft

Source Code

GitHub - csandun/WaysToReturnEmptyEnumurable

Contribute to csandun/WaysToReturnEmptyEnumurable development by creating an account on GitHub.

GitHubcsandun

ArgumentException.ThrowIfNull and ArgumentException.ThrowIfNullOrEmpty had been introduced as guard clause in .NET 6  and .NET 7 releases. They will help to throw null exceptions cleaner way.

What is ArgumentException

ArgumentNullException is a class in the .NET Framework that represents an exception when a null reference is passed to a method that does not accept it as a valid argument. This exception is thrown when a method or constructor is called with a null argument, and the method or constructor is not designed to handle that.

It is typically thrown by the runtime when a null argument is passed to a method or constructor that doesn't accept it. It can also be thrown explicitly by the developer by using the throw keyword, along with a new instance of the ArgumentNullException class, to indicate that a null argument is not valid for the method or constructor being called.

Prior to C# 10 you may have had code similar to the following using ArgumentNullException.

If the parameter 'Summary' is null, then an ArgumentNullException will be thrown.

Newly added ArgumentNullException guard clause

C# 10 (.NET 6) and C# 11 (.NET 7) introduced an improved way to avoid robust code. They are working like guard clauses.

Usage

In the preceding code, a new static method called ThrowIfNull and ThrowIfNullOrEmpty have been added to the ArgumentNullException class and allow us to check and throw ArgumentNullExceptions quickly.

Using this kind of guard clauses instead of if statement checks results in cleaner code.

I like it; hopefully, Microsoft can continue adding more guard clauses in future .NET releases.

Until they release, I am using two excellent libraries from the open-source community.

1. amantinband/throw

GitHub - amantinband/throw: A simple, fluent, extensible, and fully customizable library for throwing exceptions for projects using .NET 6+

A simple, fluent, extensible, and fully customizable library for throwing exceptions for projects using .NET 6+ - GitHub - amantinband/throw: A simple, fluent, extensible, and fully customizable li...

GitHubamantinband

2. ardalis/GuardClauses

GitHub - ardalis/GuardClauses: A simple package with guard clause extensions.

A simple package with guard clause extensions. Contribute to ardalis/GuardClauses development by creating an account on GitHub.

GitHubardalis

This is a trendy library through .NET people. Which is a set of best practices for input validation and error handling in C# code, developed by Steve Smith (ardalis)

Here we will identify Deep copy/ Deep clone methods and their behavior and performances in JavaScript and Typescript.                        

Introduction

What is Deep Copy

In JavaScript/Typescript, a deep copy is a copy of an object that creates a new instance of the object rather than simply creating a reference to the original object. Any changes to the copied object will not affect the original object and vice versa.

This Copy that will be a faithful reflection of the base object, with all attributes and fields at every nesting level into  new references.

Why Deep Copy

The purpose of a deep copy in Angular is to create a new instance of an object completely independent of the original object. This is useful when you want to change an object without affecting the original object, such as when working with data that should not be modified.

For example, when creating a new component in Angular, you may want to pass data to that component without modifying the original data. Using a deep copy ensures that any changes made to the data within the component do not affect the original data.

Additionally, when you have a large and complex data structure, using a deep copy can be useful to create a new copy of the data and keep the original data intact.

In general, it's a good practice to use deep copy when working with data in Angular to avoid unintended side-effects that could occur as a result of modifying the original data.

Deep Copy vs Shallow Copy

A shallow copy, on the other hand, creates a new instance of the object but it only copies the reference of the nested objects, not the nested objects themselves. This means that any changes made to the nested objects in the copied object will also affect the original object, and vice versa.

When we talk about Angular deep copy, Shallow copy cannot be forgotten. I will discuss Shallow Copy in a separate blog post in the future.

Deep Copy Methods

A deep copy can be created in several ways, including:

1.  Using JSON stringify function

This method uses the built-in JSON object to convert the object to a JSON string, and then parse it back into an object. This method is simple and works for most basic objects.

let obj2 = JSON.parse(JSON.stringify(obj));

Do not Use in

Best to use

2.  Using lodash.cloneDeep(obj) method

This method uses the lodash library to create a deep copy of an object.

You need to install the lodash library first by running npm install lodash and then import it in your component or service where you want to use it:

import * as _ from 'lodash';

let obj2 = _.cloneDeep(obj);

Warning

Best to use

3. 🔥🔥 @angular-devkit deepClone(obj) method🔥🔥

This method creates a deep copy of an object using the deepClone  method from the @angular-devkit/core package. It can handle large objects and preserve all data types. But it requires an additional package to be installed and imported.

@angular-devkit/build-angular

Angular Webpack Build Facade. Latest version: 15.1.1, last published: 3 days ago. Start using @angular-devkit/build-angular in your project by running `npm i @angular-devkit/build-angular`. There are 197 other projects in the npm registry using @angular-devkit/build-angular.

npm

import { deepClone } from '@angular-devkit/core';

let obj2 = deepClone(obj);

Warning

Best to use

Even deprecated, this would be my favorite method to deep copy JavaScript objects.

4.  Object.assign({}, obj) (nested properties are shallow copy)

This method uses the built-in Object.assign method to create a new object with the properties of the original object. This method is also simple and works for most basic objects, but it only creates a shallow copy.

let obj2 = Object.assign({}, obj);

Do not Use in

It creates a shallow copy of the object and nested objects within the original object are still references to the original objects.

Best to use

Performance Comparison

I am created a sample Angular application and tested above 4 methods using a benchmark library.

Here I am used benchmark.js npm library to compare methods.

benchmark

A benchmarking library that supports high-resolution timers & returns statistically significant results.. Latest version: 2.1.4, last published: 6 years ago. Start using benchmark in your project by running `npm i benchmark`. There are 230 other projects in the npm registry using benchmark.

npm

Performance results

Now lets check the performance comparisons.

Here I am simplify this table into a barchart.

Summarizing with performances

According to the benchmark test, the fastest way to  Object.assign. Unfortunately it supports only shallow copy.

Both the JSON.parse(JSON.stringify(obj)) and @angular-devkit/core/src/utils/object.deepClone(obj) methods can be good choices for deep copying large objects, depending on the specific requirements of your application.

My opinion

Per the performance testing, 🔥Devkit 🔥 will be a good choice for large and small objects with comparatively speed than other options and preserve all data types. If you do not have a specific requirement and do not like 3rd party libraries, the 🔥JSON stringify function🔥 best option.

Source Code

Before run this code install dependent libraries.

1. loadsh
2. devkit
3. benchmark.js in npm

import {Component} from '@angular/core';
import * as Benchmark from 'benchmark';
import * as _ from 'lodash';
import {deepCopy} from "@angular-devkit/core/src/utils/object";


@Component({
    selector: 'app-root',
    template: `
        <h1>Cloning Method Comparison</h1>
    `
})
export class AppComponent {


    ngOnInit() {
        var obj = {
            name: 'John Doe',
            age: 30,
            address: {
                city: 'New York',
                country: 'USA'
            }
        };

        const bench = new Benchmark.Suite('Cloning Method Comparison')
            .add('JSON.parse(JSON.stringify(obj))', () => {
                JSON.parse(JSON.stringify(obj))
            })
            .add('Object.assign({}, obj)', () => {
                Object.assign({}, obj)
            })
            .add('lodash.cloneDeep(obj)', () => {
                _.cloneDeep(obj)
            })
            .add(' deepCopy(obj)', () => {
                deepCopy(obj)
            })
            .on('cycle', (event: any) => {
                console.log(String(event.target));
            })
            .on('complete', function () {
                bench.forEach((o: any) => {
                    console.log(o.stats.mean);
                });
            })
            .run({async: true});


        let obj2 = {
            orderNumber: 12345,
            customer: {
                firstName: "John",
                lastName: "Doe",
                email: "john.doe@example.com",
                phone: "555-555-5555"
            },
            shippingAddress: {
                street: "123 Main St",
                city: "Anytown",
                state: "CA",
                zip: "12345"
            },
            billingAddress: {
                street: "456 Park Ave",
                city: "Anytown",
                state: "CA",
                zip: "54321"
            },
            items: [
                {
                    itemName: "Item 1",
                    itemId: "123",
                    quantity: 2,
                    price: 19.99
                },
                {
                    itemName: "Item 2",
                    itemId: "456",
                    quantity: 1,
                    price: 9.99
                },
                {
                    itemName: "Item 3",
                    itemId: "789",
                    quantity: 3,
                    price: 29.99
                }
            ],
            total: 89.97,
            status: "Processing",
            placedOn: "2022-12-01T09:30:00Z"
        };

        const benchLargeObject = new Benchmark.Suite('Cloning Method Comparison')
            .add('JSON.parse(JSON.stringify(obj))', () => {
                JSON.parse(JSON.stringify(obj2))
            })
            .add('Object.assign({}, obj)', () => {
                Object.assign({}, obj2)
            })
            .add('lodash.cloneDeep(obj)', () => {
                _.cloneDeep(obj2)
            })
            .add('devkit.deepCopy(obj)', () => {
                deepCopy(obj)
            })
            .on('cycle', (event: any) => {
                console.log(String(event.target));
            })
            .on('complete', function() {
                benchLargeObject.forEach((o: any) => {
                    console.log(o.stats.mean);
                } );
            })
            .run({ async: true });
    }
}

Resources

1. What is the best and most efficient way to deep clone an object in JavaScript?
2. Angular deep copy vs shallow copy 🔥

Every day you see only a blinking cursor on Command Line or Powershell? No colors, same font every day. Do you want to change your windows in Terminal beautiful way?

This post is helping to customize your Windows 11 Terminal beautifully and nicely.

Below Terminal will use your dreamy Terminal today onwards.

Pre Requisites

1. Windows 11 Terminal / Windows Terminal  from MS Store

Get Windows Terminal from the Microsoft Store

The Windows Terminal is a modern, fast, efficient, powerful, and productive terminal application for users of command-line tools and shells like Command Prompt, PowerShell, and WSL. Its main features include multiple tabs, panes, Unicode and UTF-8 character support, a GPU accelerated text rendering…

2.Oh-My-Posh packages

Home | Oh My Posh

A prompt theme engine for any shell.

Oh My Posh

3.Nerd fonts

Nerd Fonts - Iconic font aggregator, glyphs/icons collection, & fonts patcher

Iconic font aggregator, collection, & patcher: 3,600+ glyph/icons, 40+ patched fonts: Hack, Source Code Pro, more. Popular glyph collections: Font Awesome, Octicons, Material Design Icons, and more

Nerd FontsRyan L McIntyre

4.Cascadia Code Fonts

GitHub - microsoft/cascadia-code: This is a fun, new monospaced font that includes programming ligatures and is designed to enhance the modern look and feel of the Windows Terminal.

This is a fun, new monospaced font that includes programming ligatures and is designed to enhance the modern look and feel of the Windows Terminal. - GitHub - microsoft/cascadia-code: This is a fun...

GitHubmicrosoft

Steps to reach your dreamy Terminal

1. Get The Windows Terminal

• In Windows 11, you have an inbuilt Terminal application. You can find it through the apps list.
• If you are using Windows 10, you want to download the Terminal from the Store. Here is the downloadable link for the Windows Terminal.

2. Install the Cascadia Code font And Nerd Font

Cascadia Code font

Cascadia Code is a power line compatible font that is already used in Visual studio as well. Cascadia Code has a unique and lovely character set most compatible with Terminal.

This link is the Cascadia Code release page.

Nerd font

Nerd font has been used in Oh-My-Posh symbols. Download your favorite font style from here.

Here I am using 'Hack Nerd Font' fonts. It is my favorite one through the Nerd font collection.

Then install both fonts in the windows font directory.

3. Install Oh-My-Posh packages in PowerShell

The Oh-My-Posh is a theme engine for any shell. It is customizable, Portable, and colorable. Believe me, Oh-My-Posh is a friendly tool for customizing your Terminal.

i. First, Open a PowerShell prompt and run the following command:

This command installs a couple of things:

• oh-my-posh.exe - Windows executable
• themes - The latest Oh My Posh themes

Create a PowerShell profile and add theme settings

ii. Second, identify whether your Powershell profile file exists or not on your PC.

iii. Third, open notepad using

iv. Fourth, Add prompt command to the profile file.

Edit the profile file by adding this command.

Customization of the theme

You can choose your favorite one through the plenty of themes by providing the Oh-My-Posh team. (Theme list)

Themes | Oh My Posh

Oh My Posh comes with many themes included out-of-the-box. Below are some screenshots of the more common themes.

Oh My Posh

You can change the theme using the theme path.

There are two possible values the --config flag can handle:

1. A path to a local configuration file

2.  A URL pointing to a remote config

DONE !!!!

Now you can see like this.

Oh-My-Posh gives me an exciting look at the boring Windows Terminal. Come on!!!!! ✌😂

References

1. Youtube - How to set up an awesome prompt with your Git Branch, Windows Terminal, PowerShell, + Cascadia Code!
2. BlogPost - How to make a pretty prompt in Windows Terminal with Powerline, Nerd Fonts, Cascadia Code, WSL, and oh-my-posh
3. oh-My-posh documentation - documentation

C# code for efficiently reducing the size of a JPEG image based on the quality threshold.

Usecase

If you remember, I posted a blog post last week on "Convert base64 string to image and showing in a table using Angular Pipe." In this blog post, I used a byte array to show the table through angular code.

Convert base64 string to image and show in a table using Angular Pipe

Parameterize Pipe to transform the base64array string to a base64 image

CSandun BlogsChathuranga

Accidently, I got a performance issue on the API side because the API call is too slow when I am using large files. QA engineers also reported it.

How do I fix the above issue?

Working on the problem

I used the below method to reduce the size of the image quality.

Explanation

Decreasing the size of a JPEG image by increasing the compression will also decrease the quality of the image. I reduced the size of a JPEG image using the Image class.

By decreasing the jpegQuality (which should be 0-100), you can increase the compression at the cost of lower image quality. See the Encoder.Quality field for more information.

Here is an example where you can see how jpegQuality affects image quality.

This is how I fixed the performance issue reported by QA engineers. I hope you will learn something from my mistaken issue.

Summary of the best practices of REST API with a huge mind map.
"REST API Design Rulebook" is a book by Mark Masse that provides guidelines for designing REST APIs. Here I used it as a reference to define my rule set and the best practices.

Introduction

As a developer, you may find yourself needing to build or consume a REST API at some point in your career. REST APIs are a popular way for systems to communicate with each other over the web, and they offer many benefits such as being easy to use and maintain. However, it's important to follow best practices when designing and building a REST API to ensure it is reliable, scalable, and easy to use for clients.

Unfortunately, not all developers follow best practices when building an API. This can lead to issues such as confusing or inconsistent URL conventions, which can make the API more difficult to use and understand. In this blog post, we'll cover the most important best practices for designing and building a REST API from a developer's perspective. Here I  introduced a set of rules to remember well. As well I designed a huge mind map to store the rules in your brain. By following these best practices, you can build an API that is easy to use and understand, and avoid common pitfalls that can lead to frustration for API users.

"REST API Design Rulebook" is a book by Mark Masse that provides guidelines for designing REST APIs. Here I used it as a reference to define my rule set and the best practices.

REST API Design Rulebook

In todayâ??s market, where rival web services compete for attention, a well-designed REST API is a must-have feature. This concise book presents a set of API design rules, drawn primarily … - Selection from REST API Design Rulebook [Book]

O’Reilly Online LearningMark Masse

REST API Mindmap sharable image

1. What is REST API

Here we are discussing, "What is REST?", main constraints, and benefits.  Furthermore here shows how to communicate with clients and servers through HTTP. I am hoping to deep dive into this soon in another blog post.

2. URI Definition

A URI (Uniform Resource Identifier) is a string of characters that identifies a resource on the web. In the context of a REST API, it is common to use URLs to identify resources, as they specify both the name and location of the resource.

In this section, I put some best practices for using URI. We can discuss this in a more informative way in the near future.

3. URI  Authority Design

In a URI, the authority is the part of the URI that specifies the location of the resource. According to the PDF, there are 4 archetypes for modeling resources in URI. We will discuss this topic in the future more descriptively. Keep in touch with my blog.

4. URI Path Design

The path portion of a URI is the part of the URI that follows the authority and specifies the name and location of the resource being accessed. It is important to follow best practices when designing the path of a URI to ensure it is easy to use and understand.
This is the most critical section for a backend developer who designs well REST API. I plan to write a blog post on this section soon.

5. URI Query Design

The query portion of a URI is the part of the URI that follows the path and specifies additional information about the resource being accessed. The query is typically made up of one or more key-value pairs separated by an ampersand (&).

Here are some best practices for designing the query portion of a URI. I put them much as, possible into this section. Go through the mind map and follow these practices in your code base.

6. HTTP Methods

In the context of a REST API, HTTP methods (also known as "verbs") are used to specify the desired action to be performed on a resource. This section is the most important one for the developer's life. Keep in touch with descriptive blog posts on this in the future.

7. Response Codes

In a REST API, HTTP response codes are used to indicate the status of a request. They provide information about whether the request was successful or encountered an error and provide additional information about the nature of the error.

Here I put most high-level error patterns and usage. We can discuss the most important response codes and other codes in the next couple of blogs.

8. Versioning

9. Client Concerns

10. Documentation

Documentation is an important part of any REST API. It provides information about the API's functionality, resources, and available operations, as well as any requirements or restrictions. We will discuss more tools and techniques near future.

11. HATEOS

12. Resources

"REST API Design Rulebook" is a book by Mark Masse that provides guidelines for designing REST APIs. Here I used it as the main reference to improve my best practices on REST API.

I hope this information has been helpful! Let me know if you have any further questions. I will plan to discuss the above topics from a REST API blog series. Keep in touch on my blog site. Happy Coding!!

The benchmarking technique aids in calculating the performance metrics of a single or multiple sections of code in your application. Benchmark can assist you in identifying the parts of your source code that require optimization.

What's a Benchmark?

A benchmark is a basic test that delivers a set of quantifiable statistics that can assist you in determining whether or not a modification to your code has increased, decreased, or had no influence on the overall performance. It is essential to have an understanding of the performance metrics that are associated with the methods that make up your application to make use of them during the process of code optimization.

Benefits of Benchmarking a source code

• Benchmarking is the process of comparing the performance of code snippets, usually against a predefined baseline.
• Benchmarking can assist in identifying performance bottlenecks in an application. (By identifying bottlenecks, you can determine the changes needed in your source code to improve the application's performance and scalability.)

GitHub - dotnet/BenchmarkDotNet: Powerful .NET library for benchmarking

Powerful .NET library for benchmarking. Contribute to dotnet/BenchmarkDotNet development by creating an account on GitHub.

GitHubdotnet

BenchmarkDotNet helps you to transform methods into benchmarks, track their performance, and share reproducible measurement experiments.

This is an open-source library that can convert your.NET methods into benchmarks, monitor those methods, and gain insights into the performance data collected. It is compatible with both.NET Framework and.NET Core applications. BenchmarkDotNet can quickly convert your methods into benchmarks, run those benchmarks, and retrieve the benchmarking results. An operation in BenchmarkDotNet terminology involves executing a method decorated with the Benchmark attribute.

Steps for benchmarking code using BenchmakDotNet

To run BenchmarkDotNet in your .NET Framework or .NET Core application, you must follow these steps:

1. Add the necessary NuGet package
2. Add Benchmark attributes to your methods
3. Create a BenchmarkRunner instance
4. Run the application in Release mode

Practical

Now we can see how to config BenchmarkDotNet library in your asp.net core project and try to retrieve some measurements on the selected Scenario.

Considering Scenario - string builder vs. string performance.

To learn the BenchmarkDotNet library with the asp.net core project, a simple development scenario is utilized here.

First, let's create a console application and install the BenchmarkDotNet NuGet package.

Create Dotnet 6 Console project and add BenchmarkDotNet library

Let’s open Visual Studio 2022 and create a .NET 6 based console application. I named it "StringBuilderVsStringBenchmarkDotnet".

This is the time to install the BenchmarkDotNet NuGet package into my console application. You can use the command given below to add the package to the console app. This command should be executed from the project directory path.

dotnet add package BenchmarkDotNet

You can also add NuGet references using Manage NuGet Packages. It will open the dialog as shown below. Search for BenchmarkDotNet and install the package.
Note: Here, I am using Rider as my main IDE.

Benchmark Code

This is the complete code for the run benchmark methods. Here we implemented two scenarios of methods.

Running benchmark project

Running the benchmarking application in release configuration is a requirement for benchmarking. When building the project, you should ideally have the optimize option set to true in csproj or the CSC command line.

Additionally, the process shouldn't have a debugger attached to it. This implies that we have two choices whenever we want to run the benchmarking application.

• Run the application from Visual Studio/Rider using Debug -> Start Without Debugging (keyboard shortcut CTRL + F5 ). The configuration should be set to release.

• OR the other option is to run the application using .Net CLI. While using .Net run command, we should ensure that we add -c release switch to the command.

dotnet run -p StringBuilderVsStringBenchmarkDotnet.csproj -c Release

Running this straightforward app might take a few seconds. This is due to BenchmarkDotNet's repeated launch of the benchmark process.

Result of the test

We can then look at the outcomes below. Here is the summary I received on my computer for your reference.

Considering the result set, we should consider two parameters:

1. Mean parameter
2. Allocated parameter

The mean parameter describes the average time it takes the method to run.
An allocated parameter describes the average allocation of the heap in memory while the method is running.

Conclusion

As we know, in programming technics,  We get the expected result from the application.

This article does not cover all of the available features and customization options. However, it should help you get started with this package. If you want to learn more, check out their documentation.

Overview | BenchmarkDotNet

BenchmarkDotNet

Sample repository

GitHub - csandun/StringBuilderVsStringBenchmarkDotnet: StringBuilder Vs String BenchmarkDotnet

StringBuilder Vs String BenchmarkDotnet. Contribute to csandun/StringBuilderVsStringBenchmarkDotnet development by creating an account on GitHub.

GitHubcsandun

Resources

1. Intro to Benchmark.net - How To Benchmark C# Code

Intro to Benchmark.net - How To Benchmark C# Code

How efficient is your code? Is the change you just made going to improve your application or not? How do you know? How important was that change? These are q...

YouTube

2. Documentation

Overview | BenchmarkDotNet

BenchmarkDotNet

3. GitHub Repo

GitHub - dotnet/BenchmarkDotNet: Powerful .NET library for benchmarking

Powerful .NET library for benchmarking. Contribute to dotnet/BenchmarkDotNet development by creating an account on GitHub.

GitHubdotnet

It's the end of 2022, and coming to a new year in your career. Many developers stay in their comfort zone with CRUD operations and basic development technologies. It is time to move with new Dotnet technologies and current industry trends and challenges in 2023.

Comfort Zone of a developer

As a developer, our comfort zone refers to the set of technologies, tools, and practices that a developer is familiar with and comfortable using. It's natural for us to feel more comfortable and confident when working within our comfort zone, as we are already familiar with the technologies and have had the opportunity to develop our skills in those areas.

However, we must also be willing to step outside of our comfort zone and learn new technologies and approaches. This can help us stay with current industry trends and expand our skillset, leading to more significant growth.

To step outside our comfort zone, we can learn new technologies,  tools, practices, and patterns and collaborate with colleagues with different skill sets. It is also helpful to seek opportunities to work on projects that require new technologies or approaches, as this can provide a structured and supported way to learn and grow.

Step outside our comfort zone with a Roadmap

For the above, we can learn new things in the coming year, set out of our comfort zone, and gain new challenges. As a Dotnet developer, I created a roadmap that is helping my thoughts and my opinions. I am doing REST Api-based developments using dot net core. And also I followed cloud technologies and microservices patterns in my carrier. My ideas entirely propose this roadmap; anyone can agree or disagree with me. Also open to suggestions for this.

NickChapsas(@nickchapsas)  inspire me to create a roadmap for this year. Based on his roadmap, I update my roadmap and I put my opinions into it.

Roadmap

Coming to the roadmap, here is my proposed mind map for Dotnet developers can follow next year.

Here red means a must know, yellow means a good to know, and a grey means maybe, and I will explain why it is a perhaps as I goand keep in mind that this is very I opinionated. This is my take it doesn't mean that everyone will agree with this. It's okay; we can disagree, but this is how I would work this, how I would hire and there is room for that.

CSandun’s .NET Backend Developer Roadmap in 2023 (1)

Xmind is the most professional and popular mind mapping tool. Millions of people use Xmind to clarify thinking, manage complex information, brainstorming, get work organized, remote and work from home WFH.

Mind Mapping AppXmind Ltd.

Shareable Roadmap Image

How to give you contribute to improving the roadmap

Please share your thoughts and changes for this. I can update this with your suggestions.

GitHub repository

GitHub - csandun/dotnet-roadmap-2023

Contribute to csandun/dotnet-roadmap-2023 development by creating an account on GitHub.

GitHubcsandun

Thoughts

Cheers, It is time to move with new Dotnet technologies and current industry trends and challenges in 2023. Let's do it in 2023.

My inspiration repositories and roadmaps.

1. My .NET backend developer roadmap for 2022

My .NET backend developer roadmap for 2022

Check out my courses: https://nickchapsas.comBecome a Patreon and get source code access: https://www.patreon.com/nickchapsasHello everybody I’m Nick and in ...

YouTube

2. Nick's .NET Backend Developer Roadmap for 2022

GitHub - Elfocrash/.NET-Backend-Developer-Roadmap: Nick’s Roadmap for a .NET Backend Developer working with Microservices

Nick&#39;s Roadmap for a .NET Backend Developer working with Microservices - GitHub - Elfocrash/.NET-Backend-Developer-Roadmap: Nick&#39;s Roadmap for a .NET Backend Developer working with Microser...

GitHubElfocrash

3. ASP.NET Core Developer Roadmap

GitHub - MoienTajik/AspNetCore-Developer-Roadmap: Roadmap to becoming an ASP.NET Core developer in 2022

Roadmap to becoming an ASP.NET Core developer in 2022 - GitHub - MoienTajik/AspNetCore-Developer-Roadmap: Roadmap to becoming an ASP.NET Core developer in 2022

GitHubMoienTajik