DEV Community: Satya Biswal

Builder Design Pattern using C#

Satya Biswal — Sun, 11 Feb 2024 10:25:30 +0000

Table of content

Introduction
Intent
Participants
Example
Use Cases

Introduction

The Builder Design Pattern is a Creational design pattern in C# and other object-oriented programming languages.

It is used to construct complex objects step by step, allowing the construction process to vary independently from the actual representation of the object.

This pattern is particularly useful when you have an object with many possible configurations and it's not desirable to have a large number of constructors with different parameter combinations.

Intent:

Separate the construction of a complex object from its representation.
Allow the same construction process to create different representations.
Provide a clear and understandable way to construct an object, especially when it involves a large number of parameters or configuration options.

Participants:

Builder: An abstract interface that defines the steps and operations needed to construct a product.
Concrete Builder: Implementations of the Builder interface, which provide specific methods for building and configuring the product.
Director: This class orchestrates the construction process using a builder to create a product. It's not always necessary, but it can be used to ensure that the construction process follows a specific order.
Product: The final object that's being constructed, representing the complex object.

Example:

Let's consider an example of building a Pizza object using the Builder pattern. We'll have a Pizza class with various properties like size, crust type, toppings, etc., and a PizzaBuilder to create Pizza objects step by step.

// Product
class Pizza
{
    public string Size { get; set; }
    public string CrustType { get; set; }
    public List<string> Toppings { get; set; }

    public void Display()
    {
        Console.WriteLine($"Size: {Size}, Crust: {CrustType}, Toppings: {string.Join(", ", Toppings)}");
    }
}

// Builder
interface IPizzaBuilder
{
    void SetSize(string size);
    void SetCrustType(string crustType);
    void AddTopping(string topping);
    Pizza Build();
}

// Concrete Builder
class MargheritaPizzaBuilder : IPizzaBuilder
{
    private Pizza pizza = new Pizza();

    public void SetSize(string size)
    {
        pizza.Size = size;
    }

    public void SetCrustType(string crustType)
    {
        pizza.CrustType = crustType;
    }

    public void AddTopping(string topping)
    {
        pizza.Toppings.Add(topping);
    }

    public Pizza Build()
    {
        return pizza;
    }
}

// Director (optional)
class PizzaDirector
{
    private IPizzaBuilder builder;

    public PizzaDirector(IPizzaBuilder builder)
    {
        this.builder = builder;
    }

    public Pizza Construct()
    {
        builder.SetSize("Medium");
        builder.SetCrustType("Thin");
        builder.AddTopping("Cheese");
        builder.AddTopping("Tomato Sauce");
        return builder.Build();
    }
}

Usage

var margheritaBuilder = new MargheritaPizzaBuilder();
var pizzaDirector = new PizzaDirector(margheritaBuilder);
var margheritaPizza = pizzaDirector.Construct();

margheritaPizza.Display();

Output

Size: Medium, Crust: Thin, Toppings: Cheese, Tomato Sauce

Use Cases:

Building Complex Objects: The Builder pattern is useful when you need to create complex objects with multiple configuration options. It provides a more readable and maintainable way to construct such objects.
Configuring Immutable Objects: In situations where you want to create immutable objects (objects whose state cannot be changed after creation), the Builder pattern is a good fit. You can build the object step by step and then create an immutable instance.
Variety of Configurations: When you have multiple configurations or variations of an object, using a builder can simplify the creation process and improve code readability.
Fluent Interfaces: Builders often make use of a fluent interface, which allows you to chain method calls together for a more expressive and intuitive configuration process.
Unit Testing: The Builder pattern is helpful in unit testing when you need to create objects for testing purposes. It allows you to create specific instances with different configurations easily.

Prototype Design Pattern using C#

Satya Biswal — Sun, 11 Feb 2024 10:05:24 +0000

Table of content

Introduction
Intent
Participants
Example
Use Cases

Introduction:

The Prototype design pattern is a Creational design pattern.
It is used to creating new objects by copying an existing object, known as the prototype.
This pattern is used when the cost of creating a new object is more expensive or complex than copying an existing one.

Intent:

Specify the kind of objects to create using a prototypical instance, which is cloned to create new objects.
Promote object creation that is efficient and independent of the concrete classes being instantiated.
Avoid costly object creation operations by copying existing objects.

Participants:

Prototype (IPrototype): This is an interface or an abstract class that defines a method for cloning itself. The Clone method is the key feature of this pattern.
Concrete Prototype (ConcretePrototype): Classes that implement the IPrototype interface. They provide concrete implementations of the Clone method.
Client: The client is responsible for creating new objects by requesting clones from a prototype. The client doesn't need to know the concrete class of the objects; it works with the IPrototype interface.

Example:

Let's consider an example of a simple shape cloning system. We have an IShape interface representing shapes, and concrete shape classes implementing the Clone method to create new instances.
Prototype

// Prototype (IPrototype)
public interface IShape
{
    IShape Clone();
    void GetInfo();
}

Concrete Prototype

// Concrete Prototype (ConcretePrototype)
public class Rectangle : IShape
{
    private int width;
    private int height;

    public Rectangle(int width, int height)
    {
        this.width = width;
        this.height = height;
    }

    public IShape Clone()
    {
        return new Rectangle(width, height);
    }

    public void GetInfo()
    {
        Console.WriteLine($"Rectangle - Width: {width}, Height: {height}");
    }
}


public class Circle : IShape
{
    private int radius;

    public Circle(int radius)
    {
        this.radius = radius;
    }

    public IShape Clone()
    {
        return new Circle(radius);
    }

    public void GetInfo()
    {
        Console.WriteLine($"Circle - Radius: {radius}");
    }
}

Usage

IShape originalRectangle = new Rectangle(10, 20);
IShape clonedRectangle = originalRectangle.Clone();

IShape originalCircle = new Circle(5);
IShape clonedCircle = originalCircle.Clone();

originalRectangle.GetInfo();
clonedRectangle.GetInfo();

originalCircle.GetInfo();
clonedCircle.GetInfo();

Output
Rectangle - Width: 10, Height: 20 Rectangle - Width: 10, Height: 20 Circle - Radius: 5 Circle - Radius: 5

Use Cases:

Efficient Object Creation: Use the Prototype pattern when the cost of creating an object is expensive (e.g., database calls or complex initialization) compared to cloning. Cloning can be a more efficient way to obtain new instances.
Configuration Management: When your application requires multiple instances with different configurations, the Prototype pattern can be used to create a base prototype object and clone it with different configurations.
Stateful Objects: If you need to create multiple instances of objects with internal state, using the Prototype pattern helps in preserving the internal state when cloning.
Reducing Subclass Proliferation: When you have a hierarchy of classes, the Prototype pattern can reduce the need for creating numerous subclasses by allowing dynamic object creation through cloning.

Message Sessions In Azure Service Bus(FIFO Pattern).

Satya Biswal — Sun, 30 Aug 2020 18:30:43 +0000

Introduction:

In this article, we will discuss sessions in the Azure Service bus queue for absolute beginners.

What is Session in Azure Service Bus?

Azure Service bus sessions ensure ordered handling of unbounded messages. Sessions are useful if your application demands an ordered message delivery (FIFO Pattern) or waits for a response after the message being delivered (Request-Response Pattern).

In this article, we'll be discussing FIFO Pattern.

Problem:

Let's assume we're building an application where we'll send a series of messages which are related to each other and moreover the sequence how it will be received and processed is very important. Looks easy. But there is a catch. There might be multiple receivers. Now how we'll guarantee the sequential delivery and ensures that single receiver receives and process all messages of the series. Here is the representational image.

The Azure Service Bus is not prescriptive about the nature of the relationship between messages and doesn't define a model for determining where a message sequence starts or ends.

Solution:

By assigning same session id to each message of the series we can assure the sequential delivery of the messages. When using sessions the service bus queue creates another virtual sub-queue inside and ensure FIFO pattern.

When the receiver receives one message it holds an exclusive lock on all messages with the received messages session-id that exists in the queue. That exclusive lock will be held till the last message of that session received.

Following are a few important points about sessions:

Sessions are not available for Basic price tier.
Once session is enabled for a queue, normal sending and receiving of messages won't be available in that queue. Every message should be sent and received with a session lock.

Conclusion:

There are many more features of Azure Service bus and session is one of them. I will be coming up with more articles about the rest of the features.

Watch this space for a code file link.

Useful articles related to Service Bus:

How to Send and Receive messages through Azure Service Bus Queue using .Net Core Client.

Cover Image Courtesy: Photo by Scott Webb on Unsplash

How to Send and Receive messages through Azure Service Bus Queue using .Net Core Client.

Satya Biswal — Sat, 29 Aug 2020 16:54:47 +0000

Introduction:

In this article, we'll explore the process of transmitting and receiving messages via Azure Service Bus Queues with the aid of a .Net Core Client.

Source code: https://github.com/TitanRintu/AzureQueueDemo
Video File: https://youtu.be/rtZ6Y7ked5I

What is Azure Service Bus Queue?

Imagine we need to create an Order Processing Application, where a User can submit an order using a client application (such as a mobile app, website, or Windows app), and a separate server will handle the order through a service. The clients are actively sending orders, and the service is responsible for receiving and processing them. Now, let's consider a scenario where, due to a natural disaster, the server will be unavailable for one hour. What will happen to the orders placed during that time? Since the server is inaccessible, these orders will not reach the server, resulting in a loss for the Order Processing Company.

Possible Solution:

The challenge at hand is to establish separation between the two systems. By decoupling these systems, we can ensure that no orders are lost in the future. To achieve this, we need to introduce a mechanism that allows us to store orders for later processing. Microsoft Azure offers a solution to this problem in the form of Service Bus Queues. With Service Bus Queues, we can store orders and process them at a later time. The following diagram illustrates how a Service Bus Queue functions.

Definition:

The Azure Service Bus Queue is a fully managed enterprise integration message broker. A Service bus can decouple applications and services. The service bus offers a reliable and secure platform for the transfer of data and State. The data transfer between applications and services happened using messages. A Message is in binary format and can contain JSON, XML, or just plain text.

Representational diagram of Service Bus Queues:

Namespace:

The namespace is a container for message queues. Every message queue must be created under a Namespace.

Queue:

Messages are sent to and received from queues. Queues offer FIFO message delivery to one or more competing consumers. This means messages will be received in the same order as they have added to the queue.

Benefits of Message Queue:

Temporal Decoupling:

A key benefit of using queues is Temporal decoupling. Let's understand how the process works.

The sender sends the messages to the queue.
Messages from the sender will be stored in the queue.
The receiver reads the messages from the queue. For the above process, the Sender and Receiver don't have to be sending and receiving the message at the same time. And Receiver and Sender needn't process the same message at the same time. Therefore the whole process is decoupled.

Load Leveling:

Consider an application called App1 (sender) that sends messages, and on the receiving end, there's a service named Ser1 (receiver) responsible for receiving and processing those messages. App1 can transmit a maximum of 100 messages per second, while Ser1 can handle up to 10 messages per second. There are no intermediary components between App1 and Ser1, so as soon as App1 sends a message, Ser1 must promptly receive and process it.

Initially, App1 sends 10 messages per second, and Ser1 can effectively receive and process them. However, let's assume that App1 suddenly increases its message rate to 100 messages per second. Due to Ser1's limited capacity, it can only process 10 messages, causing the remaining 90 messages to either time out or go unprocessed.

By introducing a message queue, App1 can send all 100 messages, which will be stored in the queue. Ser1 can then retrieve messages from the queue and process them at its own pace. This approach eliminates the need to modify App1 or Ser1, ensuring that no data or messages are lost. This is how a message queue assists in load balancing.

How to Create Queues:

Queues can be created by:

Azure Portal
PowerShell
Azure CLI.
RMT or Resource Manager Templates.

Please follow the article from Microsoft to create a queue through Azure Portal.
https://docs.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-portal

How to Create Queue through Azure CLI

First of all, we need to create a resource group (if not exists already). ```ps

az group create --name ResourceGroupName --location eastus


* Since the message queues reside inside a namespace, We need to create a namespace first.(if namespace not exists)
```ps


az servicebus namespace create --resource-group
 ResourceGroupName --name OrderManagementNamespace --location eastus

After that we need to create a queue using the following command. ```ps

az servicebus queue create --resource-group ResourceGroupName --namespace-name OrderManagementNamespace --name ordermanagementqueue


* Now the message queue has been created successfully.
To check the message queue has been created or not. We need to run the following command.
```ps


az servicebus queue list --resource-group ResourceGroupName --namespace-name OrderManagementNamespace

Sending and Receiving Messages

We have created the Azure Service Bus Queue. Now Let's send and receive messages from the Azure Service bus queue through a .Net core Console Application.

I have used a console application for explaining the code, but you can create other types of project to achieve the same.

Let's create a blank solution named AzureQueueDemo and add the following project types into the solution.

AzureQueueDemo.Domain:Dotnet Standard class library.
AzureQueueDemo.Receiver:Dotnet Core Console app.
AzureQueueDemo.Sender:Dotnet Core Console app.

Let's add a new class named OrderInformation in AzureQueueDemo.Domain project.



    public class OrderInformation  
       {  
           public Guid OrderId { get; set; }  
           public string OrderName { get; set; }  
           public int OrderQuantity { get; set; }  
       }

Add AzureQueueDemo.Domain project into AzureQueueDemo.Sender and AzureQueueDemo.Receiver as Project reference.

Add following Nuget Package to the AzureQueueDemo.Sender AND AzureQueueDemo.Receiver.

Microsoft.Azure.ServiceBus -v4.1.3
NewtonSoft.Json -v12.0.3

Let's Navigate to the Azure portal now. I have created a Namespace named: OrderManagementNamespace and queue named ordermanagementqueue.

portal.azure.com -> OrderManagementNamespace -> ordermanagementqueue ->Shared Access Policies.

Then add a new Shared access policy, named QueuePolicy. Check the "Manage" Checkbox. Then Save the policy and reopen it. Upon reopen you can see 4 additional properties named Primary Key, Secondary Key, Primary Connection String and Secondary Connection string.

We need to use the primary Connection string to send and receive the messages.

Let's open the program class of AzureQueueDemo.Sender project and Add List Of OrderInformation to it.



    static List<OrderInformation> Orders = new List<OrderInformation>()  
           {  
               new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="Dell Laptop",  
                   OrderQuantity=10  

               },  
                new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="Apple Laptop",  
                   OrderQuantity=10  

               },  
                 new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="Lenovo Laptop",  
                   OrderQuantity=10  

               },  
                  new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="MI Laptop",  
                   OrderQuantity=10  

               }   

           };

How to send messages.

Then add the following variables in the program class of AzureQueueDemo.Sender like following.



class Program  
       {  

    private static string AZURE_SERVICE_BUS_CONNECTIONSTRING = "<REPLACE WITH YOUR PRIMARY CONNECTION STRING OF *QueuePolicy*";  
    private static string QUEUE_NAME = "ordermanagementqueue";

NOTE: Remove EntityPath from the Connection string which you can find at the end of the Connection string.

Let me explain what we'll write about in the program.

we'll display a message to the user "Do you want to send Order Information? If Yes, Press Y."
then we'll Capture the user input & If the user input is "Y", then proceed to the next code.
To Send the message we need to create a variable of type IQueueClient.To know more about IQueueClient, visit here.
initialize IQueueClient with QueueClient.
The Queueclient constructor accepts two parameters. The Azure service bus queue connection string and the queue name.
Provide the primary connection string as the first argument and queue name as the second parameter.
Then Iterate the orders list which we have already initialized.
Serialize the Item by using JsonConvert.SerializeObject (Add Newtonsoft.Json as a namespace, if not added.)
Create a new "Message" object after converting the JSON Object to Bytes by calling Encoding.UTF8.GetBytes() method.
Now the message object is ready.
Call the SendAsync() method of QueueClient. for e.g. client.SendAsync(message)

Here is the complete code of the program class of AzureQueueDemo.Sender project.



class program
{
static List<OrderInformation> Orders = new List<OrderInformation>()  
           {  
               new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="Dell Laptop",  
                   OrderQuantity=10  

               },  
                new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="Apple Laptop",  
                   OrderQuantity=10  

               },  
                 new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="Lenovo Laptop",  
                   OrderQuantity=10  

               },  
                  new OrderInformation()  
               {  
                   OrderId = Guid.NewGuid(),  
                   OrderName="MI Laptop",  
                   OrderQuantity=10  

               }   

           }; 

    private static string AZURE_SERVICE_BUS_CONNECTIONSTRING = "<REPLACE WITH YOUR PRIMARY CONNECTION STRING Of Senderpolicy REMOVE entitypath AND ITS VALUE FROM THE STRING>";  
           private static string QUEUE_NAME = "ordermanagementqueue";  
           static async Task Main(string[] args)  
           {  
               Console.WriteLine("Do you want to send Order Information? If Yes , Press Y.");  
               var result = Console.ReadLine();  
               if (result.Equals("Y"))  
               {  
                   IQueueClient client = new QueueClient(AZURE_SERVICE_BUS_CONNECTIONSTRING, QUEUE_NAME);  
                   foreach (var item in Orders)  
                   {  
                       var messageBody = JsonConvert.SerializeObject(item);  
                       var message = new Message(Encoding.UTF8.GetBytes(messageBody));  
                       await client.SendAsync(message);  
                       Console.WriteLine($"Sending Message : {item.OrderName.ToString()} ");  

                   }  
               }  
               Console.Read();  
           }  
}

How to receive messages.

To receive a message we need a variable of type QueueClient class. We need to use the RegisterMessageHandler method of the QueueClient.
It accepts two parameters. The first one is the Func delegate and the second one is the MessageHandlerOptions.

Func delegate, handles the message processing.
MessageHandlerOptions tell the func how to process the messge.

In MessageHandlerOptions we can handle

How to complete the message.

How many concurrent calls client can handle.

How to handle exceptions if any during the processing of the message.

Following is the complete code of AzureQueueDemo.Receiver program class.



    class Program  
       {  
           private static string AZURE_SERVICE_BUS_CONNECTIONSTRING = "<REPLACE WITH YOUR PRIMARY CONNECTION STRING Of QueuePolicy. REMOVE entitypath AND ITS VALUE FROM THE STRING>";  
           private static string QUEUE_NAME = "ordermanagementqueue";  
           private static IQueueClient client;  
           static async Task Main(string[] args)  
           {  
               await ReceiveMessagesAsync();  
           }  

           private static  async Task ReceiveMessagesAsync()  
           {  
               await Task.Factory.StartNew(() =>  
               {  
                   client = new QueueClient(AZURE_SERVICE_BUS_CONNECTIONSTRING, QUEUE_NAME);  
                   var options = new MessageHandlerOptions(ExceptionMethod)  
                   {  
                       MaxConcurrentCalls = 1,  
                       AutoComplete = false  
                   };  
                   client.RegisterMessageHandler(ExecuteMessageProcessing, options);  
               });  
               Console.Read();  

           }  

           private static async Task ExecuteMessageProcessing(Message message, CancellationToken arg2)  
           {  
               var result = JsonConvert.DeserializeObject<OrderInformation>(Encoding.UTF8.GetString(message.Body));  
               Console.WriteLine($"Order Id is {result.OrderId}, Order name is {result.OrderName} and quantity is {result.OrderQuantity}");  
               await client.CompleteAsync(message.SystemProperties.LockToken);  
           }  

           private static async Task ExceptionMethod(ExceptionReceivedEventArgs arg)  
           {  
               await Task.Run(() =>  
              Console.WriteLine($"Error occured. Error is {arg.Exception.Message}")  
              );  
           }  
       }

Now we are ready with Sender and Receiver code. Make sure to add both projects as startup project to see the result side by side.

Now lets run the project and see the output window for result.

Conclusion:
In the above article, we have learned how to send and receive messages from the Azure Service Message Queue. The source code has been uploaded to Git Hub and can be downloaded from the following link. https://github.com/TitanRintu/AzureQueueDemo
Cover image courtesy:

(Photo by Waldemar Brandt on Unsplash)