Working with the .NET 8 gRPC API

We'll examine a contemporary API architecture today. Using.NET C#, we will create a basic gRPC service that carries out CRUD (Create, Read, Update, Delete) actions.

gRPC is a modern, open-source, high-performance Remote Procedure Call (RPC) framework that can run in any environment. It enables client and server applications to communicate transparently and simplifies the building of connected systems. gRPC is based on the idea of defining a service and specifying the methods that can be called remotely with their parameters and return types. On the server side, the server implements this interface and runs a gRPC server to handle client calls. On the client side, the client has a stub that provides the same methods as the server.

gRPC is designed to work with a variety of programming languages, making it an ideal choice for multi-language systems. It uses Protocol Buffers (protobuf) as its Interface Definition Language (IDL) and its underlying message interchange format, which is a powerful binary serialization toolset and language.

History of gRPC

gRPC was initially created by Google and is a part of the Cloud Native Computing Foundation (CNCF). It was publicly announced in February 2015 and has evolved from the earlier Stubby, an RPC system that Google developed internally to connect their large-scale microservices.

One of the main reasons for developing gRPC was to address the need for efficient communication in microservices architectures where lightweight data exchange is crucial. gRPC's use of HTTP/2 as the transport protocol allows for features like concurrently streaming data in both directions, multiplexing multiple requests over a single connection, header compression, etc.

The evolution of gRPC is marked by its adoption across various organizations outside Google for both internal microservices communication and client-facing APIs. It supports several languages and platforms, providing developers with a versatile tool for building distributed systems.

Prerequisites

• Visual Studio 2019 or later with the ASP.NET and web development workload.
• .NET 5.0 SDK or later.
• A basic understanding of gRPC.

Step 1. Set up the .NET Core gRPC Project

1. Open Visual Studio.
2. Click on "Create a new project."
3. Search for the "gRPC Service" template and select it. Click "Next."
4. Name the project BookGrpcService and the solution BookGrpcService. Click "Create."

Step 2. Define the Proto File

Create or update the Protos/book.proto file. This protocol buffer file defines the structure of the gRPC service and the messages that are exchanged.

syntax = "proto3";
option csharp_namespace = "BookGrpcService";
package book;
// The Book service definition
service Books {
  rpc CreateBook (CreateBookRequest) returns (Book);
  rpc GetBook (GetBookRequest) returns (Book);
  rpc UpdateBook (UpdateBookRequest) returns (Book);
  rpc DeleteBook (DeleteBookRequest) returns (DeleteBookResponse);
  rpc ListBooks (ListBooksRequest) returns (ListBooksResponse); // Adding this line
}
// The request message containing the ID
message GetBookRequest {
  int32 id = 1;
}
// The request message containing the book details
message CreateBookRequest {
  string title = 1;
  string author = 2;
}
// The request message containing full book information
message UpdateBookRequest {
  int32 id = 1;
  string title = 2;
  string author = 3;
}
// The request message for deleting book by ID
message DeleteBookRequest {
  int32 id = 1;
}
// The response message containing status
message DeleteBookResponse {
  string status = 1;
}
message ListBooksRequest {}
message ListBooksResponse {
  repeated Book books = 1; // A list of books
}
// The message representing a Book
message Book {
  int32 id = 1;
  string title = 2;
  string author = 3;
}

Step 3. Implement the Service in C#

create a new service implementation in Services/BookService.cs that supports CRUD operation based on the Proto file.

using Grpc.Core;
using System.Collections.Generic;
using System.Threading.Tasks;
using BookGrpcService;
namespace BookGrpcService.Services
{
    public class BooksService : Books.BooksBase
    {
        private static readonly List<Book> books = new List<Book>
        {
            new Book { Id = 1, Title = "1984", Author = "George Orwell" },
            new Book { Id = 2, Title = "Brave New World", Author = "Aldous Huxley" },
            new Book { Id = 3, Title = "To Kill a Mockingbird", Author = "Harper Lee" }
        };
        private static int nextId = 4;
        public override Task<Book> CreateBook(CreateBookRequest request, ServerCallContext context)
        {
            var book = new Book
            {
                Id = nextId++,
                Title = request.Title,
                Author = request.Author
            };
            books.Add(book);
            return Task.FromResult(book);
        }
        public override Task<Book> GetBook(GetBookRequest request, ServerCallContext context)
        {
            var book = books.Find(b => b.Id == request.Id);
            return Task.FromResult(book);
        }
        public override Task<ListBooksResponse> ListBooks(ListBooksRequest request, ServerCallContext context)
        {
            ListBooksResponse response = new ListBooksResponse();
            response.Books.AddRange(books);
            return Task.FromResult(response);
        }
        public override Task<Book> UpdateBook(UpdateBookRequest request, ServerCallContext context)
        {
            var book = books.Find(b => b.Id == request.Id);
            if (book != null)
            {
                book.Title = request.Title;
                book.Author = request.Author;
            }
            return Task.FromResult(book);
        }
        public override Task<DeleteBookResponse> DeleteBook(DeleteBookRequest request, ServerCallContext context)
        {
            var book = books.Find(b => b.Id == request.Id);
            if (book != null)
            {
                books.Remove(book);
                return Task.FromResult(new DeleteBookResponse { Status = "Deleted" });
            }
            return Task.FromResult(new DeleteBookResponse { Status = "Book Not Found" });
        }
    }
}

Step 4. Regenerate the gRPC code

Ensure to rebuild the project to regenerate the C# gRPC code automatically.

Step 5. Testing the Service

Run the project in Visual Studio by hitting F5. Use a gRPC client tool like BloomRPC gRPC URL or PostMan to test each service operation by sending the respective requests.

Testing in Postman

Open the Postman, click on New, and choose the gRPC option.

 

Import the Proto file in Postman.

Select the ListBooks options and send a request.

 
Now, we will add a new book to the list using the CreateBook option. This gRPC service supports Create, Delete, Update, Get, and List operations. You can try it out in Postman.

Conclusion

We have successfully established a foundational gRPC service using .NET and C#. Through the implementation of a simple book management system, we have learned how to define a .proto file to structure our gRPC service and messages, and have seen how these definitions translate into server-side logic in C#.

gRPC offers significant advantages in terms of performance and flexibility when compared to traditional REST APIs, particularly in microservices architectures where efficient communication between services is crucial. Its use of HTTP/2 for transport, low overhead, and ability to generate cross-platform client and server code makes gRPC a powerful choice for modern application development.

Best ASP.NET Core 8.0.11 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.0.11 hosting is the feature and reliability. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core, their servers are optimized for PHP web applications. The performance and the uptime of the hosting service are excellent and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. 

At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its datacenters are equipped with the top equipments like cooling system, fire detection, high speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core. And the engineers do regular maintenance and monitoring works to assure its Orchard hosting are security and always up.

Read More...

Learning the Host in ASP.NET Core

The host is a key idea in ASP.NET Core that is in charge of overseeing the dependencies and lifecycle of the application. It is the environment in which the application operates and is necessary for middleware pipelines, configuration, and service setup.

Types of Hosts in ASP.NET Core

1. Generic Host (IHost)
   • Introduced in ASP.NET Core 3.0 to provide a unified hosting model.
   • Can host various types of applications, including web applications, background services, and more.
   • Works with non-HTTP workloads (e.g., worker services).
2. Web Host (IWebHost)
   • Used specifically for web applications.
   • Configures HTTP servers, middleware, and other web-specific services.
   • It is now built on top of the Generic Host starting in ASP.NET Core 3.0.

Responsibilities of the Host

The host provides the following functionalities for an ASP.NET Core application.

1. Dependency Injection (DI): It manages the application's service container and resolves services as needed.
2. Configuration: Loads and manages configuration settings from various sources like appsettings.json, environment variables, command-line arguments, and more.
3. Logging: Sets up logging providers (e.g., console, debug, file) for the application.
4. Environment Management: Defines the environment the app is running in (e.g., Development, Staging, Production) using IHostEnvironment.
5. Application Lifetime Management: Manages the application's lifecycle, including startup, shutdown, and handling graceful termination.

Components of the Host

1. Host Builder: The HostBuilder or WebHostBuilder is used to configure and build the host.
2. Startup Class: The Startup class defines the middleware pipeline and services configuration.
3. Hosting Environment: Provides information about the environment, such as Development, Staging, or Production.
4. Server: Includes the web server implementation (e.g., Kestrel, IIS) for web hosts.

Building the Host

Here’s how a host is typically built in an ASP.NET Core application.

Using Generic Host (IHost)

var builder = Host.CreateDefaultBuilder(args)
    .ConfigureServices((context, services) =>
    {
        // Add application services here
        services.AddHostedService<MyBackgroundService>();
    })
    .ConfigureLogging(logging =>
    {
        logging.ClearProviders();
        logging.AddConsole();
    });
var app = builder.Build();
await app.RunAsync();

Using Web Host (IWebHost)

var builder = WebHost.CreateDefaultBuilder(args)
    .UseStartup<Startup>()
    .UseUrls("http://localhost:5000");

var host = builder.Build();

await host.RunAsync();

Key APIs for the Host

1. IHost
   • Represents the generic host in ASP.NET Core.
   • Example: var host = Host.CreateDefaultBuilder(args).Build();
2. IWebHost
   • Represents the web-specific host.
   • Example: var webHost = WebHost.CreateDefaultBuilder(args).Build();
3. IHostEnvironment
   • Provides access to environment-specific details.
   • Example: env.EnvironmentName, env.ContentRootPath.

Hosting Environment

The hosting environment determines how the application behaves in different scenarios. It is specified using the ASPNETCORE_ENVIRONMENT environment variable. Common values include.

• Development
• Staging
• Production

You can access the environment in Startup.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }
}

Real-World Example: Web Application Host

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

In this example.

• Host.CreateDefaultBuilder(args) creates a default Generic Host.
• ConfigureWebHostDefaults configures it for web hosting using Startup.

Best ASP.NET Core 8.0.8 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 8.0 hosting is the feature and reliability. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core, their servers are optimized for PHP web applications. The performance and the uptime of the hosting service are excellent and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. 

At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its datacenters are equipped with the top equipments like cooling system, fire detection, high speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core. And the engineers do regular maintenance and monitoring works to assure its Orchard hosting are security and always up.

 

Read More...

Use a .NET Web API to implement the Mediator Pattern

Within an application, it is occasionally necessary for one object or component to connect with another. There are no problems if the components are small. Real-time applications, on the other hand, consist of numerous components, all of which must communicate with one another. The more components there are in the application, the more complex it becomes. In this post, we'll look at how to use the Mediator approach to solve this issue and how to include it into a.NET Web API.

The Real-Time Problem

Let's understand the real-time problem using the following example.

We have four components.

• Component A
• Component B
• Component C
• Component D

  

These components need to communicate with each other. For example, if Component A wants to communicate with Component B, Component A must have a reference to Component B and use that reference to call Component B's methods. Similarly, if any component wants to send a message to another component, it must know the reference of the other component and use it to call its methods.

The objects are tightly coupled, meaning many objects know each other. In the example, we have only four objects. However, in real-world applications, you might have hundreds of objects that need to communicate with each other. It will be very difficult and will increase the complexity of the application.

How to Reduce the Coupling Between the Components Using Mediator Pattern?

A mediator design pattern is a behavioral design pattern that restricts the direct communication between entities and forces them to interact through a mediator object. It reduces the communication complexity between the components.

In the Mediator pattern, direct communication between components is restricted. Instead, all components communicate indirectly through a dedicated mediator object. The Mediator object serves as the communication hub for all components. Each component interacts with the mediator object, which then routes the messages to the appropriate destination component.

Let's consider the above example and re-design the application using the Mediator pattern as described below.

 

Real-world use cases for Mediator Pattern

Chat Application is a perfect example of the Mediator design pattern. In this application, there are users and groups. Users can join groups and share their messages within the group. When 'Person A' shares a message in the chat group, it is sent to all members who have joined the group. In this scenario, the chat group acts as the Mediator.

Components involved in Mediator Pattern

• Component: Components are various classes with their own business logic. Each component references a mediator, as defined by the mediator interface.
• Mediator: The Mediator interface defines methods for communication with components, mainly featuring a notification method.
• Concrete Mediator: Concrete Mediators manage the interactions between various components.

namespace MediatorDesignPattern
{
    public interface IMediator
    {
        // This Method is used to send the Message to users who are registered with the group
        void SendMessage(string message, IUser user);
        // This method is used to register a user with the group
        void RegisterChatUser(IUser user);
    }
}

namespace MediatorDesignPattern
{
    public interface IUser
    {
        int UserId { get; }
        void SendMessage(string message);
        void RecieveMessage(string message);
    }
}

namespace MediatorDesignPattern
{
    public class ChatUser : IUser
    {
        private readonly IMediator _mediator;
        private readonly string _username;
        private readonly int _userId;
        public int UserId => _userId;
        public ChatUser(IMediator mediator, string username, int userId)
        {
            _mediator = mediator;
            _username = username;
            _userId = userId;
        }
        public void RecieveMessage(string message)
        {
            Console.WriteLine($"{_username} received message: {message}");
        }
        public void SendMessage(string message)
        {
            Console.WriteLine($"{_username} sending message: {message}");
            _mediator.SendMessage(message, this);
        }
    }
}

namespace MediatorDesignPattern
{
    public class ChatMediator : IMediator
    {
        private readonly Dictionary<int, IUser> UsersList; // List of users to whom we want to communicate
        public ChatMediator()
        {
            UsersList = new Dictionary<int, IUser>();
        }
        // To register the user within the group
        public void RegisterChatUser(IUser user)
        {
            if (!UsersList.ContainsKey(user.UserId))
            {
                UsersList.Add(user.UserId, user);
            }
        }
        // To send the message in the group
        public void SendMessage(string message, IUser chatUser)
        {
            foreach (var user in UsersList.Where(u => u.Key != chatUser.UserId))
            {
                user.Value.RecieveMessage(message);
            }
        }
    }
}

namespace MediatorDesignPattern
{
    class Program
    {
        static void Main(string[] args)
        {
             var chatGroup = new ChatMediator();
             var PersonA = new User(chatGroup, "Person A", 1);
             var PersonB = new User(chatGroup, "Person B", 2);
             var PersonC = new User(chatGroup, "Person C", 3);
             chatGroup.RegisterChatUser(PersonA);
             chatGroup.RegisterChatUser(PersonB);
             chatGroup.RegisterChatUser(PersonC);
             PersonA.SendMessage("Any one is available for trip this week?");
             PersonB.SendMessage("I am in");
             PersonC.SendMessage("I am not available");
             Console.Read();
        }
    }
}

Output

How to Implement Mediator Pattern in .NET Web API?

MediatR is a widely used library that simplifies the implementation of the Mediator pattern in .NET applications.

Step 1. Install the MediatR package.

You can do this through the NuGet Package Manager or by running the following command in the Package Manager Console.

Install-Package MediatR
Install-Package MediatR.Extensions.Microsoft.DependencyInjection

Bash

Step 2. Define the Request and Response Models.

public class SendMessageCommand : IRequest<string>
{
    public string Sender { get; set; }
    public string Message { get; set; }
}

This class represents the request model for sending a message. It implements the IRequest<string> interface from MediatR, indicating that it expects a response of type string.

Step 3. Create the Handler.

public class SendMessageHandler : IRequestHandler<SendMessageCommand, string>
{
    public Task<string> Handle(SendMessageCommand request, CancellationToken cancellationToken)
    {
        // Logic to handle the message (e.g., routing it to other components)
        string response = $"[{request.Sender}]: {request.Message}";
        return Task.FromResult(response);
    }
}

This class handles the processing of the SendMessageCommand. It implements the IRequestHandler<SendMessageCommand, string> interface, which indicates it handles SendMessageCommand requests and returns a string response. The Handle method processes the request and returns a formatted string containing the sender and the message.

Step 4. Configure MediatR in the Startup.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMediatR(typeof(Startup).Assembly);
    }
}

In the Startup class, MediatR is added to the service collection using services.AddMediatR(typeof(Startup).Assembly). This registers all MediatR handlers found in the specified assembly.

Step 5. Send a Message Using MediatR.

public class ChatController : ControllerBase
{
    private readonly IMediator _mediator;
    public ChatController(IMediator mediator)
    {
        _mediator = mediator;
    }
    [HttpPost("send")]
    public async Task<IActionResult> SendMessage([FromBody] SendMessageCommand command)
    {
        string result = await _mediator.Send(command);
        return Ok(result);
    }
}

This controller handles incoming HTTP requests for sending messages. It injects an instance of IMediator via its constructor. The SendMessage action method receives a SendMessageCommand object as its parameter, sends the command using MediatR, and returns the result as an HTTP response.

Flow

• When a POST request is made to the sending endpoint of the ChatController, the SendMessageCommand is created with the sender's name and message content.
• The SendMessageCommand is sent to MediatR using _mediator.Send(command).
• MediatR locates the appropriate handler (SendMessageHandler) for the command.
• The SendMessageHandler processes the command by formatting the sender's name and message into a string and returns this string as the response.
• The ChatController returns the formatted string as the HTTP response.

This approach centralizes communication through MediatR, reducing direct dependencies between components and making the code more modular and easier to maintain.

ASP.NET Core 9.0 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 9.0 hosting is the feature and reliability. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core, their servers are optimized for PHP web applications. The performance and the uptime of the hosting service are excellent and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. 

At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its datacenters are equipped with the top equipments like cooling system, fire detection, high speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core. And the engineers do regular maintenance and monitoring works to assure its Orchard hosting are security and always up.

Read More...

Effective Task Scheduling in C# Using the Round Robin Algorithm

 One popular scheduling technique in computer science, particularly in operating systems, is the round robin algorithm. It is made to work with time-sharing systems in which every process is given a set time slice or quantum, guaranteeing that every process receives an equal amount of CPU time. When there are several processes that must be carried out without starving, this method works especially well. This article will examine the Round Robin algorithm, comprehend its fundamentals, and demonstrate its implementation in C# with a real-world use case.

Round Robin Algorithm

The round-robin algorithm is a preemptive scheduling algorithm that cycles through all processes in the ready queue in a circular order. Each process is given a fixed time slice during which it can execute. If a process is not complete within its time slice, it is moved to the end of the queue, and the CPU scheduler picks the next process in line. This cycle continues until all processes are completed. The main advantage of the round-robin algorithm is its simplicity and fairness, as each process gets an equal opportunity to execute.

Key Features of Round Robin Algorithm

1. Time Quantum: A fixed time slice assigned to each process.
2. Preemption: The algorithm allows processes to be preempted and moved to the end of the queue.
3. Fairness: Ensures all processes get an equal share of CPU time.
4. Simple Implementation: Easy to implement and understand.

Round Robin Algorithm in C#

To implement the Round Robin algorithm in C#, we will follow these steps:

1. Define a class to represent a process.
2. Implement a method to simulate the Round Robin scheduling.
3. Test the implementation with a practical use case example.

Step 1. Process Representation

Define a Process class to represent each process in the system. This class will have properties such as Process ID, Burst Time, and Remaining Time.

public class Process
{
    public int ProcessID { get; set; }
    public int BurstTime { get; set; }
    public int RemainingTime { get; set; }

    public Process(int processID, int burstTime)
    {
        ProcessID = processID;
        BurstTime = burstTime;
        RemainingTime = burstTime;
    }
}

Step 2. Round Robin Scheduling

Implement a method to simulate the Round Robin scheduling. This method will take a list of processes and a time quantum as input and simulate the execution of processes based on the Round Robin algorithm.

using System;
using System.Collections.Generic;

public class RoundRobinScheduler
{
    public static void Schedule(List<Process> processes, int timeQuantum)
    {
        int time = 0;
        Queue<Process> readyQueue = new Queue<Process>(processes);

        while (readyQueue.Count > 0)
        {
            Process currentProcess = readyQueue.Dequeue();
            if (currentProcess.RemainingTime <= timeQuantum)
            {
                time += currentProcess.RemainingTime;
                Console.WriteLine($"Process {currentProcess.ProcessID} completed at time {time}");
                currentProcess.RemainingTime = 0;
            }
            else
            {
                time += timeQuantum;
                currentProcess.RemainingTime -= timeQuantum;
                readyQueue.Enqueue(currentProcess);
                Console.WriteLine($"Process {currentProcess.ProcessID} executed for {timeQuantum} units; remaining time: {currentProcess.RemainingTime}");
            }
        }
    }
}

Step 3. Practical Use Case Example

We will create a sample use case to demonstrate the round-robin algorithm. We will define a list of processes with varying burst times and execute them using our round-robin scheduler.

class Program
{
    static void Main(string[] args)
    {
        List<Process> processes = new List<Process>
        {
            new Process(1, 10),
            new Process(2, 4),
            new Process(3, 5),
            new Process(4, 7)
        };

        int timeQuantum = 3;

        Console.WriteLine("Round Robin Scheduling:");
        RoundRobinScheduler.Schedule(processes, timeQuantum);
    }
}

Step 4. Output

 

Conclusion

A straightforward yet effective scheduling technique that guarantees equitable CPU time distribution among activities is the round robin method. A time-sharing system where every process has an equal chance to run can be simulated by using the Round Robin algorithm in C#. An outline of the Round Robin algorithm, its salient characteristics, and a real-world use case example illustrating its use were presented in this article. Designing effective and equitable scheduling systems for a range of applications can be facilitated by comprehending and utilizing the Round Robin algorithm.

ASP.NET Core 9.0 Hosting Recommendation

One of the most important things when choosing a good ASP.NET Core 9.0 hosting is the feature and reliability. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core, their servers are optimized for PHP web applications. The performance and the uptime of the hosting service are excellent and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. 

At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its datacenters are equipped with the top equipments like cooling system, fire detection, high speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core. And the engineers do regular maintenance and monitoring works to assure its Orchard hosting are security and always up.

Read More...