The Builder Pattern is among the Creational Patterns of the Gang Of Four (GOF). To understand this pattern, we first need to understand its intent.

Intent

“Separate the construction of a complex object from its representation so that the same construction process can create different representations.” –GOF

The preceding definition of the Builder Design Pattern is given by the GOF. It might be difficult to understand by reading the definition, so let us understand it by dividing it up.

So the moral of the story is "Separate object construction from its representation".

Now let's understand the implementation of this pattern using a real-world scenario.

Scenario

On one fine day a Pizza vendor has placed an order to a software company. His requirement was to get the list of contents to make a Pizza based on the requested Pizza type. The company has accepted the order and has provided this definition to his Project Manager Mr. X. Then Mr. X has explained all the requirements to his developer Mr. Y and asked him to develop a program for that.

Approach 1

Mr. Y has begun thinking of the definition. He thought that there are many possible contents in a Pizza, like size, dough type, cheese type and so on. So first he created enumerations for all these selections. Then he created one class called "Pizza". In this class he has created a parameterized constructor with all required contents to create the Pizza. This constructor accepts the contents and sets the values in private variables. Now Mr. X has accept the functionality for the contents from the client, so he created a method called "PizzaContent" to print the entire list of contents to generate the Pizza.

public class Pizza  
    {  
        private readonly DoughType doughType;  
        private readonly bool isRedPepper;  
        private readonly Size size;  
        private readonly CheeseType cheeseType;  
        private readonly List<string> vegetables;  

        public Pizza(DoughType doughType, bool isRedPepper, Size size,CheeseType cheeseType,List<string> vegetables)  
        {  
            this.doughType = doughType;  
            this.isRedPepper = isRedPepper;  
            this.size=size;  
            this.cheeseType=cheeseType;  
            this.vegetables=vegetables;  
        }  

        public void PizzaContent()  
        {  
            Console.WriteLine("Pizza with {0}", doughType);  

            if (isRedPepper)  
                Console.WriteLine("Red Pepper");  

            Console.WriteLine("Size: {0}", size);  
            Console.WriteLine("Cheese Type: {0}", cheeseType);  
            Console.WriteLine("Vegetables:");  

            foreach (var item in vegetables)  
            {  
                Console.WriteLine(" {0}", item);  
            }  
        }  
    }  
    public enum DoughType  
    {  
        Neapolitan_Pizza_Dough = 1,  
        NewYorkStyle_Pizza_Dough = 2,  
        SquarePan_Pizza_Dough = 3  
    }  

    public enum CheeseType  
    {  
        American = 1,  
        Swiss = 2,  
    }  

    public enum Size  
    {  
        Small = 1,  
        Medium = 2,  
        Large = 3  
    }

Client-Side Code

Mr. Y has created an object of the Pizza class where he has provided the contents of his choice to create a Pizza and called the method to get the contents.

    static void Main(string[] args)  
            {  
                new Pizza(DoughType.Neapolitan_Pizza_Dough, true, Size.Medium, CheeseType.Swiss, new List<string> { "Tomato", "Capsicum","Corn" }).PizzaContent();  
                Console.ReadKey();  
            }

Output

Mr. Y has checked the application and it was built and run successfully.

Mr. Y was very happy that he has completed the given task successfully. He has provided the demo to his Project Manager Mr. X. Mr. X has gone through the application and has discovered a problem. The constructor is very large, in other words the constructor has many parameters. He asked Mr. Y to solve that problem.

Huge Constructor / Too many parameters

Approach 2

Again Mr. Y has started working on it. He has made some changes in the Pizza class. He has converted a variable into properties and removed the parameterized constructor.

 public class Pizza  
        {  
           public DoughType doughType {get; set;}  
           public bool isRedPepper { get; set; }  
           public Size size { get; set; }  
           public CheeseType cheeseType { get; set; }  
           public List<string> vegetables { get; set; }  

            public void PizzaContent()  
            {  
                Console.WriteLine("Pizza with {0}", doughType);  
                if (isRedPepper)  
                    Console.WriteLine("Red Pepper");  
                Console.WriteLine("Size: {0}", size);  
                Console.WriteLine("Cheese Type: {0}", cheeseType);  
                Console.WriteLine("Vegetables:");  
                foreach (var item in vegetables)  
                {  
                    Console.WriteLine(" {0}", item);  
                }  
            }  
        }  

        public enum DoughType  
        {  
            Neapolitan_Pizza_Dough = 1,  
            NewYorkStyle_Pizza_Dough = 2,  
            SquarePan_Pizza_Dough = 3  
        }  

        public enum CheeseType  
        {  
            American = 1,  
            Swiss = 2,  
        }  

        public enum Size  
        {  
            Small = 1,  
            Medium = 2,  
            Large = 3  
        }

Client-Side Code

Mr. Y has created an object of the Pizza class and has set all the properties for that object and called the method.

static void Main(string[] args)  
      {  
          var pizza = new Pizza();  
          pizza.doughType = DoughType.Neapolitan_Pizza_Dough;  
          pizza.isRedPepper = true;  
          pizza.size = Size.Large;  
          pizza.cheeseType = CheeseType.American;  
          pizza.vegetables = new List<string> { "Tomato", "Corn" };  

          pizza.PizzaContent();  

          Console.ReadKey();  
      }

Output

Mr. Y has built and run the application again.

This time Mr. Y thought that he has solved the problem. He has shown the application to his Project Manager Mr. X. Mr. X was a little happy but explained that the client needs to remember all the properties, so you need to figure out some solution.

Need to remember all the properties

Approach 3

Mr. Y has again started working on that and he got the solution for not remembering the properties. This time he didn't change anything in the Pizza class.

    public class Pizza  
        {  
           public DoughType doughType {get; set;}  
           public bool isRedPepper { get; set; }  
           public Size size { get; set; }  
           public CheeseType cheeseType { get; set; }  
           public List<string> vegetables { get; set; }  

            public void PizzaContent()  
            {  
                Console.WriteLine("Pizza with {0}", doughType);  
                if (isRedPepper)  
                    Console.WriteLine("Red Pepper");  
                Console.WriteLine("Size: {0}", size);  
                Console.WriteLine("Cheese Type: {0}", cheeseType);  
                Console.WriteLine("Vegetables:");  
                foreach (var item in vegetables)  
                {  
                    Console.WriteLine(" {0}", item);  
                }  
            }  
        }  
        public enum DoughType  
        {  
            Neapolitan_Pizza_Dough = 1,  
            NewYorkStyle_Pizza_Dough = 2,  
            SquarePan_Pizza_Dough = 3  
        }  

        public enum CheeseType  
        {  
            American = 1,  
            Swiss = 2,  
        }  

        public enum Size  
        {  
            Small = 1,  
            Medium = 2,  
            Large = 3  
        }

Mr. Y has created a new class "MyPizzaBuilder". In this class he has implemented the following three major things:

1. Create one method "GetPizza" that returns an instance of a Pizza class
2. Create methods ("PrepareDough", "AppyVegetables", "AppyCheese", "AddCondiments") to set properties
3. Create one more method "CreatePizza" that initializes an object of the Pizza class and calls the preceding methods

    public class MyPizzaBuilder  
        {  
            Pizza pizza;  

            public Pizza GetPizza()  
            {  
                return pizza;  
            }  

            public void CreatePizza()  
            {  
                pizza = new Pizza();  

                PrepareDough();  
                ApplyVegetables();  
                ApplyCheese();  
                AddCondiments();  
            }  

            private void AddCondiments()  
            {  
                pizza.isRedPepper = true;  
            }  

            private void ApplyCheese()  
            {  
                pizza.cheeseType = CheeseType.American;  
            }  

            private void ApplyVegetables()  
            {  
                pizza.vegetables = new List<string> { "Tomato", "Corn" };  
            }  

            private void PrepareDough()  
            {  
                pizza.doughType = DoughType.Neapolitan_Pizza_Dough;  
                pizza.size = Size.Large;  
            }  
        }

Client-Side Code

In the client side Mr. Y has created an object of the "MyPizzaBuilder" class and called the "CreatePizza" method. As we have seen the "CreatePizza" method calls all the methods that are required to set the properties. So in this way the client does not need to remember all the properties.

static void Main(string[] args)  
        {  
            var builder = new MyPizzaBuilder();  
            builder.CreatePizza();  
           var pizza = builder.GetPizza();  
            pizza.PizzaContent();  

            Console.ReadKey();  
        }

Output

Again Mr. Y has built and run the application and was very happy. He just explained the solution to his Project Manager. The Project Manager appreciated his efforts and asked one question "What if we want to create another type of Pizza?" Mr. Y was realized that he must copy "MyPizzaBuilder" and then change the definition of creating a Pizza.

If you want to create another type of Pizza then you need to create another class and copy from MyPizzaBuilder and change the definition of creating a Pizza. This is not a good practice.

Approach 4

Mr. Y has become fed up with the situation and this time he just wants a concrete solution. So he has thought about it and came up with the solution. In this approach he also didn't change anything in the "Pizza" class.

public class Pizza  
    {  
       public DoughType doughType {get; set;}  
       public bool isRedPeeper { get; set; }  
       public Size size { get; set; }  
       public CheeseType cheeseType { get; set; }  
       public List<string> vegetables { get; set; }  

        public void PizzaContent()  
        {  
            Console.WriteLine("Pizza with {0}", doughType);  
            if (isRedPeeper)  
                Console.WriteLine("Red Peeper");  
            Console.WriteLine("Size: {0}", size);  
            Console.WriteLine("Cheese Type: {0}", cheeseType);  
            Console.WriteLine("Vegetables:");  
            foreach (var item in vegetables)  
            {  
                Console.WriteLine(" {0}", item);  
            }  
        }  
    }  
    public enum DoughType  
    {  
        Neapolitan_Pizza_Dough = 1,  
        NewYorkStyle_Pizza_Dough = 2,  
        SquarePan_Pizza_Dough = 3  
    }  

    public enum CheeseType  
    {  
        American = 1,  
        Swiss = 2,  
    }  

    public enum Size  
    {  
        Small = 1,  
        Medium = 2,  
        Large = 3  
    }

This time he has created an abstract class "PizzaBuilder" and declared all the methods that were used to set the properties as abstract.

    public abstract class PizzaBuilder  
        {  
            protected Pizza pizza;  

            public Pizza GetPizza()  
            {  
                return pizza;  
            }  

            public void CreateNewPizza()  
            {  
                pizza = new Pizza();  
            }  

            public abstract void PrepareDough();  
            public abstract void ApplyVegetables();  
            public abstract void ApplyCheese();  
            public abstract void AddCondiments();  
        }

Mr. Y has inherited the preceding abstract class into "MyPizzaBuilder" and implemented all the abstract methods. So in this way he has a solution and implemented it. Now if the client wants to create another type of pizza then he must inherit the same abstract class and implement the properties.

    public class MyPizzaBuilder : PizzaBuilder  
        {  
            public override void AddCondiments()  
            {  
                pizza.isRedPeeper = true;  
            }  

            public override void ApplyCheese()  
            {  
                pizza.cheeseType = CheeseType.American;  
            }  

            public override void ApplyVegetables()  
            {  
                pizza.vegetables = new List<string> { "Tomato", "Corn" };  
            }  

            public override void PrepareDough()  
            {  
                pizza.doughType = DoughType.Neapolitan_Pizza_Dough;  
                pizza.size = Size.Large;  
            }  
        }

Mr. Y has created one more class, "PizzaMaker", to construct an object using the builder abstract class. So in this class the client must pass a builder and the methods are called of that specific concrete builder.

    public class PizzaMaker  
    {  
        private readonly PizzaBuilder builder;  

        public PizzaMaker(PizzaBuilder builder)  
        {  
            this.builder = builder;  
        }  

        public void BuildPizza()   
        {  
            builder.CreateNewPizza();  
            builder.PrepareDough();  
            builder.ApplyVegetables();  
            builder.ApplyCheese();  
            builder.AddCondiments();  
        }  

        public Pizza GetPizza()   
        {  
            return builder.GetPizza();  
        }  
    }

Let's check what Mr. Y has done so far using a Class Diagram. Mr. Y has created the "Pizza" class that was our product. Then he created a "PizzaBuilder" abstract class that was our builder. Then he has created two concrete builders, in other words "MyPizzaBuilder" and "TomatoPizzaBuilder". In the future the client can also add more concrete builders, in other words more types of Pizzas. Finally he has created the "PizzaMaker" class that was our director.

Participants

• Builder (PizzaBuilder): Specifies an abstract interface for creating parts of a Product object.

• ConcreteBuilder (MyPizzaBuilder, TomatoPizzaBuilder): Constructs and assembles parts of the product by implementing the Builder interface and defines and keeps track of the representation it creates. Provides an interface for retrieving the product.

• Director (PizzaMaker): Constructs an object using the Builder interface.

• Product (Pizza): Represents the complex object under construction. ConcreteBuilder builds the product's internal representation and defines the process by which it's assembled includes classes that define the constituent parts, including interfaces for assembling the parts into the final result.

Client-Side Code

In the client-side code Mr. Y has created an object of the "PizzaMaker" class and passed a "MyPizzaBuilder" object. Then he called the BuildPizza method that calls all the necessary methods to create a Pizza for that builder. In the third step he called the GetPizza method followed by the PizzaContent method. The same was done for "TomatoPizzaBuilder" also.

    static void Main(string[] args)  
            {  
                var pizzaMaker = new PizzaMaker(new MyPizzaBuilder());  
                pizzaMaker.BuildPizza();  
                var pizza1 = pizzaMaker.GetPizza();  

                pizza1.PizzaContent();  

                pizzaMaker = new PizzaMaker(new TomatoPizzaBuilder());  
                pizzaMaker.BuildPizza();  
                var pizza2 = pizzaMaker.GetPizza();  

                pizza2.PizzaContent();  

                Console.ReadKey();  
            }

Output

Mr. Y has built and run the application and gave the demo to Mr. X.

This time Mr. X has gone through the application and was very happy as Mr Y. has implemented "The Builder Design Pattern".

Summary

When we have multiple parameters, the order of those parameters are important and when we have different constructions, we should need to separate the construction of an object from its representation.

Open Visual Studio and create a new project

Select API as template and press OK.

As we are going to fetch the categories, let’s create a category model which has two fields - CategoryId and CategoryName.

namespace DIinCore  
{  
    public class Category  
    {  
        public int CategoryId { get; set; }  
        public string CategoryName { get; set; }  
    }  
}

Create an interface of repository having GetCategories method which returns the list of category object.

using System.Collections.Generic;  

namespace DIinCore  
{  
    public interface ICategoryRepository  
    {  
        List<Category> GetCategories();  
    }  
}

Implement the preceding interface and return some sample data. As our target is to understand dependency injection, here, we are not going to fetch the data from database rather returning hard coded ones.

using System.Collections.Generic;  
namespace DIinCore  
{  
    public class CategoryRepository : ICategoryRepository  
    {  
        public List<Category> GetCategories()  
        {  
            List<Category> categories = new List<Category>();  

            Category category = new Category() { CategoryId = 1, CategoryName = "Category1" };  
            categories.Add(category);  

            category = new Category() { CategoryId = 2, CategoryName = "Category2" };  
            categories.Add(category);  

            return categories;  
        }  
    }  
}

Assume that we are not aware of the dependency injection. Then, how will we expose the GET method from API? We used to create an instance of CategoryRepository and call the GetCategories method using that instance. So tomorrow, if there is a change in CategoryRepository it will directly affect the GET method of API as it is tightly coupled with that.

[HttpGet]  
        public async Task<IActionResult> Get()  
        {  
            CategoryRepository categoryRepository = new CategoryRepository();  
            List<Category> categories = categoryRepository.GetCategories();  

            return Ok(categories);  
        }

With the .NET Framework, we used to use containers like LightInject, NInject, Unity etc. But in .NET Core, Microsoft has provided an in-built container. We need to add the namespace, i.e., Microsoft.Extension.DependencyInjection.

So, in the startup class, inside the ConfigureServices method, we need to add our dependency into the service collection which will dynamically inject whenever and wherever we want in the project. Also, we can mention which kind of instance we want to inject - the lifetime of our instance.

Transient

It creates an instance each time they are requested and are never shared. It is used mainly for lightweight stateless services.

Singleton

This creates only single instances which are shared among all components that require it.

Scoped

It creates an instance once per scope which is created on every request to the application.

using Microsoft.AspNetCore.Builder;  
using Microsoft.AspNetCore.Hosting;  
using Microsoft.Extensions.Configuration;  
using Microsoft.Extensions.DependencyInjection;  

namespace DIinCore  
{  
    public class Startup  
    {  
        public Startup(IConfiguration configuration)  
        {  
            Configuration = configuration;  
        }  

        public IConfiguration Configuration { get; }  

        public void ConfigureServices(IServiceCollection services)  
        {  
            //services.AddTransient<ICategoryRepository, CategoryRepository>();  

            services.AddSingleton<ICategoryRepository, CategoryRepository>();  

            //services.AddScoped<ICategoryRepository, CategoryRepository>();  

            services.AddMvc();  
        }  

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)  
        {  
            if (env.IsDevelopment())  
            {  
                app.UseDeveloperExceptionPage();  
            }  

            app.UseMvc();  
        }  
    }  
}

So far, we have added our dependency to the collection. Now, it’s time to inject where we need it, i.e., in the Web API. Our GET method is inside the CategoryController and we want an instance of categoryrepository. So, let’s create a constructor of CategoryController which expects the type of ICategoryRepository. From this parameterized constructor, set the private property of type ICategoryRepository which will be used to call GetCategories from the GET method.

using Microsoft.AspNetCore.Mvc;  
using System.Collections.Generic;  
using System.Threading.Tasks;  

namespace DIinCore.Controllers  
{  
    [Route("api/Category")]  
    public class CategoryController : Controller  
    {  
        private ICategoryRepository categoryRepository { get; set; }  
        public CategoryController(ICategoryRepository categoryRepository)  
        {  
            this.categoryRepository = categoryRepository;  
        }  

        [HttpGet]  
        public async Task<IActionResult> Get()  
        {  
            List<Category> categories = categoryRepository.GetCategories();  
            return Ok(categories);  
        }  
    }  
}

Run the application and we will be able to see the result of the GET method of CategoryController. Now, even though we haven’t created an instance of CategoryRepository which is expected by CategoryController, we are able to call the GET method successfully. The instance of CategoryRepository has been resolved dynamically, i.e., our Dependency Injection.

You can download the sample code from here.

Let's see the step by step implementation,

Steps

1. Create ASP.NET Core Web API Application
2. Publish Web API Application
3. Create Virtual Machine in Azure
4. Install .NET Core and Apache in Virtual Machine
5. Host Web API Application in Virtual Machine

Create ASP.NET Web API Application

Create new project, select API as template and click on create button, which will create web API application with WeatherForcast Controller having get method.

Configure Swagger in AspnetCoreWebApi, so that we can see exposed method in UI.

In order to enable swagger, add the below nuget packages

• AspNetCore
• AspNetCore.Swagger

Add the below code in startup.cs under ConfigureServices method

services.AddSwaggerGen(c =>  
            {  
                c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "Aspnet Core Web Api", Version = "v1" });  
                var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";  
                var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);  
                c.IncludeXmlComments(xmlPath);  
            });

Add the below code in startup.cs under Configure method

app.UseSwagger();  
           app.UseSwaggerUI(c =>  
           {  
               c.SwaggerEndpoint("/swagger/v1/swagger.json", "Aspnet Core Web Api");  
               c.InjectJavascript("/swagger/custom.js");  

           });

Create AspnetCoreWebApi.xml file with the below content:

<?xml version="1.0"?>  
<doc>  
</doc>

Copy AspnetCoreWebApi.xml to D:\AspnetCoreWebApi\AspnetCoreWebApi\bin\Debug\netcoreapp3.0

Now run the application and see the result in UI.

Our application is running under localhost in our system.

Publish Web API Application

Right click on project and click on Publish

Click on Folder from left panel and select the path where you would like to save publish copy

Click on Advanced link, which will open below window

Select Release as Configuration, netcoreapp3.0 as Target Framework and Framework-Dependent as Deployment Mode

Select linux-x64 as Target Runtime, as we want to host our application in Linux environment

Click on Save button

Click on CreateProfile which will create a profile for us and will be useful for further releases

Click on Publish button which will publish our application and save in predefined path

Explore our selected path i.e. D:\AspnetCoreWebApi\AspnetCoreWebApi\bin\Release\netcoreapp3.0\publish and we can see the published data

Create Virtual Machine in Azure

Log into portal.azure.com and click on "Virtual machines".

Click on 'Add', which will open the "Create a virtual machine" wizard.

1. Select your Azure subscription. Duly note that all resources in an Azure subscription are billed together.
2. Select existing or create a new resource group. It is a collection of resources that share the same lifecycle, permissions, and policies.
3. Provide your virtual machine a name. For demo purpose, I have given it a name like 'AspNetCoreLinuxVM'.
4. Select the region that is right for you and your customers. Not all VM sizes are available in all regions.
5. Azure offers a range of options for managing the availability and resiliency of your application. We can select 'Availability Set' also but as of now, select 'No infrastructure redundancy required'.
6. Choose the base operating system or application for your VM.
7. Change the size as per your requirement and the price will be calculated accordingly.
8. Provide Username and Password which will be used later on to connect your VM.
9. Select SSH and HTTP as inbound ports

Select your disk option.

1. Premium SSD Offers high-performance, low-latency disk support for I/O-intensive applications and production workloads.

2. Standard SSD Cost effective storage option optimized for workloads that needs consistent performance at lower IOPS (Input/Output Operations Per Second) levels.

3. Standard HDD For dev/test scenarios and less critical workloads at the lowest cost.

For best performance, reliability, scalability, and access control, it is recommended to select Managed Disk for most of the virtual machine configuration. Use unmanaged disks if you need to support certain classic scenarios or want to manage Disk VHDs in your own storage account.

Keep the networking option as it is and move to Management.

Boot the diagnostics capture serial console output and screenshots of the virtual machine running on a host to help diagnose startup issues.

OS guest diagnostics gets metrics every minute for our virtual machine. We can use them to create alerts and stay informed on our applications.

Metrics are written on a storage account.

If Identity is enabled, all necessary permissions can be granted via Azure Role-based access control.

Enable auto-shutdown configures our virtual machine to automatically shut down daily.

Provide the time when we want to shutdown VM

Provide the time zone in which shutdown time is given

Subscribe for notification before the VM is shutdown

To guard our VM against accidental deletion and corruption, enable backup.

Keep Advanced option as it is and move to the Tags

A tag is not required as of now. Skip this stage and move to Review + Create.

It will validate all the inputs and show the status message.

Click on the 'Create' button.

Once the VM is created, you will be able to see the deployment details as below.

Now, in the next step, let's try to connect our recently created VM. For this, we need a public IP Address and port.

Install .NET Core and Apache in Virtual Machine

Open command prompt to connect virtual machine

Execute below command with username and IpAddress

>ssh akshayblevel@13.82.17.110

It will ask for the password

>akshayblevel@13.82.17.110's password:xxxxxxxxxx

Once it is connected, execute below command to point to the root

>akshayblevel@AspNetCoreLinuxVM:~$ sudo -i root@AspNetCoreLinuxVM:~#

Execute below commands to register microsoftkey, product repository and required dependencies. Need to execute once per machine.

>wget -q https://packages.microsoft.com/config/ubuntu/18.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb

>sudo dpkg -i packages-microsoft-prod.deb

Execute below commands in sequence in order to install .Net Core SDK,

>sudo add-apt-repository universe
>sudo apt-get update
>sudo apt-get install apt-transport-https
>sudo apt-get update
>sudo apt-get install dotnet-sdk-3.1

Install Asp.Net Core runtime

>sudo apt-get install aspnetcore-runtime-3.1

Install .Net Core runtime

>sudo apt-get install dotnet-runtime-3.1

In order to expose our application to the internet, we need IIS, Nginx or Apache as reverse proxy server that will accept HTTP request and forwards to Kestrel.

Execute below command to install Apache

>sudo apt-get install apache2

Copy public ip and run in the browser, if apache is installed correctly then you can see the apache default page

Enable modproxy modules in Apache server to make it work as a reverse proxy.

First we need to restart apache

>systemctl restart apache2

Enable modproxy module

>a2enmod proxy proxy_http proxy_html

Host Web API Application in Virtual Machine

All the configuration files in Apache are stored at /etc/apache2/conf-enabled directory. We need to create .conf file for our application.

Execute below command to create conf file

>vi /etc/apache2/conf-enabled/aspnetcorewebapi.conf

Insert below text to add in the aspnetcorewebapi.conf

<VirtualHost *:80>  
   ProxyPreserveHost On  
   ProxyPass / http://127.0.0.1:5000/  
   ProxyPassReverse / http://127.0.0.1:5000/  
   ErrorLog /var/log/apache2/aspnetcorewebapi-error.log  
   CustomLog /var/log/apache2/aspnetcodewebapi-access.log common  
</VirtualHost>

Execute below command to save the file and return back to root

>:x

Let's verify whether file is saved correctly or not by executing below command

>cat /etc/apache2/conf-enabled/aspnetcorewebapi.conf

Restart apache

>systemctl restart apache2

Create directory where we can transfer our published files.

Go to var directory

cd /var/

Create WebApi directory

mkdir WebApi

Go inside WebApi directory

cd WebApi

Now we need to transfer our published files to WebApi directory on server, for that we can use filezilla or winscp software.

Install winscp from below link

https://winscp.net/eng/download.php

Connect to server using publicip, username and password. Once it is connected we can see the folder with name as username.

Drag and drop Publish folder from left panel to right panel i.e. on server

Explore publish folder from the right side and verify all the files are uploaded correctly.

Upload Transfer files including .xml into the same folder in order to support swagger.

Now all the files are uploaded on server, in the next step we need to move files from akshayblevel directory to WebApi Directory.

Go to the akshayblevel directory

>cd /home/akshayblevel

Verify if publish folder is there or not.

>Ls

Go inside publish folder.

>cd publish

Verify if all the files are there or not.

>Ls

Copy all the files from publish folder to WebApi folder.

>cp -R /var/WebApi/*

Go to WebApi folder.

>cd /var/WebApi

Verify if all the files are there or not.

>Ls

Restart apache service and server.

systemctl restart apache2

sudo service apache2 restart

Create service file to start and monitor web app.

>vi /etc/systemd/system/kestrel-aspnetcorewebapi.service

Add the below content to the above service file, we need to provide working directory and which file should be executed.

[Unit]  
Description=Aspnet Core Web Api running on Ubuntu 18.04  
[Service]  
WorkingDirectory=/var/WebApi  
ExecStart=/usr/bin/dotnet /var/WebApi/aspnetcorewebapi.dll  
Restart=always  
RestartSec=10  
SyslogIdentifier=dotnet-demo  
User=www-data  
Environment=ASPNETCORE_ENVIRONMENT=Production  
[Install]  
WantedBy=multi-user.target

Execute the below command to save the file and return back to root.

>:x

Enable and start recently created service.

sudo systemctl enable kestrel-aspnetcorewebapi.service  
sudo systemctl start kestrel-aspnetcorewebapi.service

Now hosting is done, let's verify in the browser using public ip and we can see that our Asp.Net Core Web Application is successfully running in Linux environment.

• GraphQL In .NET Core Web API With Entity Framework Core - Part One
• GraphQL In .NET Core Web API With Entity Framework Core - Part Two
• GraphQL In .NET Core Web API With Entity Framework Core - Part Three
• GraphQL In .NET Core Web API With Entity Framework Core - Part Four

Today, we will discuss the below items in detail.

1. Aliases
2. Multiple Queries
3. Fragment
4. Named Queries
5. Variables
6. Directive
7. Optional Parameter

Aliases

Consider a scenario where you have exposed your APIs using GraphQL to multiple clients. Let’s take our existing example that we are going to expose - employee entity with certifications via API to multiple clients. Now each client wants their own naming convention for properties in an entity. One client may ask that I should get a certificate as a response; not the title. The other client may expect CertificationName as a response rather than a title, so we can’t create client specific APIs. In this situation, GraphQL alias feature will help. We need to ask the client to send alias along with the query, i.e., whatever the name they want, they just need to pass in the query and GraphQL will return the response accordingly.

In the below sample query, we have passed Employee as an alias for employee and CertificationName as the alias for title.

We can compare query and query response with alias and without alias for better understanding.

Multiple Queries

In some scenarios, you want to execute more than one query and expect the result as single json, you can do the same by giving an alias. I have given aliases like E1 & E2 and written two different queries, one to fetch employee1 and another to fetch employee2 and you can see in the response that both the employees are added in the single JSON file.

Query

{  
  E1:employee(id:1){name certifications {title}}  
  E2:employee(id:2){name certifications {title}}  
}

Query Response

{  
  "data": {  
    "E1": {  
      "name": "Akshay",  
      "certifications": [  
        {  
          "title": "MCSD"  
        },  
        {  
          "title": "Scrum Master"  
        }  
      ]  
    },  
    "E2": {  
      "name": "Panth",  
      "certifications": [  
        {  
          "title": "MCT"  
        },  
        {  
          "title": "PMP"  
        }  
      ]  
    }  
  }  
}

Fragment

In multiple queries, if you observe closely, we have added {name certifications {title}} which we want as a response, we have written multiple times. Now, assume that you want to write similar kinds of queries around 10 or 20 times, then you need to write the same in the query that many times. In order to avoid such repetitions, we can use fragment. You can write fragment on type; i.e., EmployeeType, and define what you want as a response once, and pass the same fragment in each query with three dots (…) as a prefix and you will get the same response.

Query

{  
  E1:employee(id:1){...employeeList}  
  E2:employee(id:2){...employeeList}  
}  

fragment employeeList on EmployeeType{  
  name, certifications {title}  
}

Query Response

{  
  "data": {  
    "E1": {  
      "name": "Akshay",  
      "certifications": [  
        {  
          "title": "MCSD"  
        },  
        {  
          "title": "Scrum Master"  
        }  
      ]  
    },  
    "E2": {  
      "name": "Panth",  
      "certifications": [  
        {  
          "title": "MCT"  
        },  
        {  
          "title": "PMP"  
        }  
      ]  
    }  
  }  
}

Named Queries

Now in the case where you want to write required queries and execute as and when it's required, you can write named queries, which means give the name of each query so that while executing it will ask which one you want to execute. Refer to the the below screen shot for the reference. The syntax for this is query {queryName} followed by {Actual Query}

Query

query all  
{  
  employees {name certifications {title}}  
}  
query E1  
{  
  E1:employee(id:1){name, certifications {title}}  
}

Query Response for ‘all’

{  
  "data": {  
    "employees": [  
      {  
        "name": "Akshay",  
        "certifications": [  
          {  
            "title": "MCSD"  
          },  
          {  
            "title": "Scrum Master"  
          }  
        ]  
      },  
      {  
        "name": "Panth",  
        "certifications": [  
          {  
            "title": "MCT"  
          },  
          {  
            "title": "PMP"  
          }  
        ]  
      }  
    ]  
  }  
}

Query Response for ‘E1’

{  
  "data": {  
    "E1": {  
      "name": "Akshay",  
      "certifications": [  
        {  
          "title": "MCSD"  
        },  
        {  
          "title": "Scrum Master"  
        }  
      ]  
    }  
  }  
}

Syntax to call Named Queries from Postman

Request Body

{  
"query":"query all  
                {  
                  employees {name certifications {title}}  
                }  
         query E1  
                {  
                  E1:employee(id:1){name, certifications {title}}  
                }",  
"OperationName":"all"  
}

Response

{  
    "data": {  
        "employees": [  
            {  
                "name": "Akshay",  
                "certifications": [  
                    {  
                        "title": "MCSD"  
                    },  
                    {  
                        "title": "Scrum Master"  
                    }  
                ]  
            },  
            {  
                "name": "Panth",  
                "certifications": [  
                    {  
                        "title": "MCT"  
                    },  
                    {  
                        "title": "PMP"  
                    }  
                ]  
            }  
        ]  
    }  
}

Variables

So far we have written queries where we were passing hard coded values for the employeeid, here we can create a variable which can accept the value dynamically and return the response accordingly.

With the query name we need to mention variable; i.e., $employeeId and make it mandatory using the ! symbol. Replace hard coded employee id value with the variable; i.e., $employeeId. Before executing the query we need to pass employeeId value as Query Variables.

Query

query E1($EmployeeId : ID!)  
{  
  employee(id:$EmployeeId){name, certifications {title}}  
}

Query Variables

{  
  "EmployeeId": 2  
}

Query Response

{  
  "data": {  
    "employee": {  
      "name": "Panth",  
      "certifications": [  
        {  
          "title": "MCT"  
        },  
        {  
          "title": "PMP"  
        }  
      ]  
    }  
  }  
}

Syntax to call Named Queries from Postman

Request Body

{  
"query":"query all  
                {  
                  employees {name certifications {title}}  
                }  

         query E1($EmployeeId:ID!)  
                {  
                  employee(id:$EmployeeId){name, certifications {title}}  
                }",  
"OperationName":"E1",  
"variables":{"EmployeeId":2}  
}

Response

{  
    "data": {  
        "employee": {  
            "name": "Panth",  
            "certifications": [  
                {  
                    "title": "MCT"  
                },  
                {  
                    "title": "PMP"  
                }  
            ]  
        }  
    }  
}

Directive

Consider a scenario where your expectation is to get a response based on your query parameter, for example if value for Boolean parameter is passed as true then return a long description, or else don’t consider a long description in response. So declare a variable which expects true or false, which means a long description needs to be returned or not. And along with a long description in the query we can use inbuilt directive; i.e., @include(if: {condition}).

Query

   query all($ShowLongDescription : Boolean!)  
    {  
      employees  
      {  
        id  
        name  
        email  
        mobile  
        address  
        shortDescription  
        longDescription @include(if: $ShowLongDescription)  
    }  
    }

Query Variables

{  
  "ShowLongDescription":  false  
}

Query Response

{  
  "data": {  
    "employees": [  
      {  
        "id": 1,  
        "name": "Akshay",  
        "email": "akshayblevel@gmail.com",  
        "mobile": "9999999999",  
        "address": "Hyderabad",  
        "shortDescription": "Short Description"  
      },  
      {  
        "id": 2,  
        "name": "Panth",  
        "email": "panth@gmail.com",  
        "mobile": "8888888888",  
        "address": "Vadodara",  
        "shortDescription": "SD"  
      }  
    ]  
  }  
}

Optional Parameter

In the continuation of the above directive implementation, we can declare parameter as optional. For example, if someone doesn’t pass the expected value, in that case also it should work. So we have passed false as default parameter value. If you don’t pass value for showLongDescription it won’t return longDescription by default. If you want to get longDescription in your response, you need to pass parameter value as true.

Query

query all($ShowLongDescription : Boolean=false)  
{  
  employees  
  {  
    id  
    name  
    email  
    mobile  
    address  
    shortDescription  
    longDescription @include(if: $ShowLongDescription)  
}  
}

Query Response

{  
  "data": {  
    "employees": [  
      {  
        "id": 1,  
        "name": "Akshay",  
        "email": "akshayblevel@gmail.com",  
        "mobile": "9999999999",  
        "address": "Hyderabad",  
        "shortDescription": "Short Description",  
        "longDescription": "Long Description"  
      },  
      {  
        "id": 2,  
        "name": "Panth",  
        "email": "panth@gmail.com",  
        "mobile": "8888888888",  
        "address": "Vadodara",  
        "shortDescription": "SD",  
        "longDescription": "LD"  
      }  
    ]  
  }  
}

Query

query all($ShowLongDescription : Boolean=false)  
{  
  employees  
  {  
    id  
    name  
    email  
    mobile  
    address  
    shortDescription  
    longDescription @include(if: $ShowLongDescription)  
}  
}

Query Variables

{  
  "ShowLongDescription":  true  
}

Query Response

{  
  "data": {  
    "employees": [  
      {  
        "id": 1,  
        "name": "Akshay",  
        "email": "akshayblevel@gmail.com",  
        "mobile": "9999999999",  
        "address": "Hyderabad",  
        "shortDescription": "Short Description",  
        "longDescription": "Long Description"  
      },  
      {  
        "id": 2,  
        "name": "Panth",  
        "email": "panth@gmail.com",  
        "mobile": "8888888888",  
        "address": "Vadodara",  
        "shortDescription": "SD",  
        "longDescription": "LD"  
      }  
    ]  
  }  
}

I hope this will help you guys during your GraphQL implementation.

This article explains about Azure Service Bus - Relay which has two entities - Hybrid Connection and WCF Relay. We will also see WCF Relay in detail.

A relay is used to communicate between on-premises applications and the outside world application. We can expose on-premises service endpoints to the public so that the outside world can access on-premise services from anywhere. We can have more than one listener for a single on-premise service endpoint. The biggest advantage of using this is that we have no need to open any port or any kind of firewall configuration. It uses Azure's network security without exposing our on-premise application.

Before we start implementing WCF Relay, let's revise WCF once.

Key points of WCF

1. WCF Service exposes one or more endpoints
2. An endpoint consists of ABC, i.e., Address, Binding, and Contract
3. Address is a unique Uniform Resource Locator (URI) that identifies the location of the service. It defines the network address for sending and receiving the messages.
4. Binding specifies which transport protocol to use, what message format and which any of the ws* protocols we want to use to a particular endpoint.
5. Contract provides the additional details of the structuring contents of the various messages that will be used by the various operations exposed to the particular endpoints.

Now, let's see the step by step implementation,

1. Create Relay Namespace
2. Create WCF Relay
3. Create WCF Service
4. Host WCF Service
5. WCF Client

Create Relay Namespace

• Log in to the Azure portal via portal.azure.com
• Click on '+Create a resource', expand Integration and click on 'Relay'.

Click on 'Create' button to create the relay namespace.

Give a proper name to the namespace and click on 'Create'.

Create WCF Relay

Here, we can see two entities, i.e., Hybrid Connections and WCF Relays. But we are going to create WCF Relay.

Click on '+WCF Relay' to create a new relay.

• Give a proper name to the relay.
• Select 'NetTcp' as Relay Type and click on 'Create'.

Create WCF Service (Library)

• Create a WCF Service Library application.
• Create an operation contract which expects a string parameter.
• Implement the contract and return the string.

    namespace WCFRelayLib  
    {  
        [ServiceContract(Namespace = "https://recharge.servicebus.windows.net/rechargerelay")]  
        public interface IRecharge  
        {  
            [OperationContract]  
            string DoRecharge(string message);  
        }  

        interface IRechargeChannel : IRecharge, IClientChannel { }  
    }     
    namespace WCFRelayLib  
    {  
        public class Recharge : IRecharge  
        {  
            public string DoRecharge(string message)  
            {  
                return "Recharge is done for: " + message;  
            }  
        }  
    }

Host WCF Service (Console Application)

• Create a console application to host the previously created service.
• Add a NuGet Pakage Microsoft.ServiceBus.

<?xml version="1.0" encoding="utf-8"?>  
<packages>  
  <package id="Microsoft.WindowsAzure.ConfigurationManager" version="2.0.0.0" targetFramework="net461" />  
  <package id="ServiceBus.v1_1" version="1.0.6" targetFramework="net461" />  
</packages>

• Expose NetTcpRelayBinding and host the service using ServiceHost.

    namespace WCFRelayHost  
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                string scheme = "sb";  
                string serviceNamespace = "recharge";  
                string servicePath = "https://recharge.servicebus.windows.net/rechargerelay";  
                string policy = "RootManageSharedAccessKey";  
                string accessKey = "Kn1GO+dihGWMbMLEe6DfsuxJd6ptgvfQVG6EF6GivdY=";  

                Uri address = ServiceBusEnvironment.CreateServiceUri(scheme, serviceNamespace, servicePath);  

                ServiceHost sh = new ServiceHost(typeof(Recharge),address);  

                sh.AddServiceEndpoint(typeof(IRecharge), new NetTcpRelayBinding(),address)  
                    .Behaviors.Add(new TransportClientEndpointBehavior  
                    {  
                        TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(policy, accessKey)  
                    });  

                sh.Open();  

                Console.WriteLine("Press ENTER to close");  
                Console.ReadLine();  

                sh.Close();  
            }  
        }  
    }

WCF Client (Console Application)

• Create a console application for WCF Client.
• Add NuGet Pakage Microsoft.ServiceBus.

    <?xml version="1.0" encoding="utf-8"?>  
    <packages>  
      <package id="Microsoft.WindowsAzure.ConfigurationManager" version="2.0.0.0" targetFramework="net461" />  
      <package id="ServiceBus.v1_1" version="1.0.6" targetFramework="net461" />  
    </packages>

• Get the ServiceName, ServicePath, Policy, and Accesskey from the portal.
• Implement the client code as below.

namespace WCFRelayLib  
{  
    [ServiceContract(Namespace = "https://recharge.servicebus.windows.net/rechargerelay")]  
    public interface IRecharge  
    {  
        [OperationContract]  
        string DoRecharge(string message);  
    }  

    interface IRechargeChannel : IRecharge, IClientChannel { }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Console.WriteLine("-------------------------------------------------------");  
            Console.WriteLine("Mobile Recharge");  
            Console.WriteLine("-------------------------------------------------------");  
            Console.WriteLine("Operators");  
            Console.WriteLine("1. Vodafone");  
            Console.WriteLine("2. Airtel");  
            Console.WriteLine("3. JIO");  
            Console.WriteLine("-------------------------------------------------------");  

            Console.WriteLine("Operator:");  
            string mobileOperator = Console.ReadLine();  
            Console.WriteLine("Amount:");  
            string amount = Console.ReadLine();  
            Console.WriteLine("Mobile:");  
            string mobile = Console.ReadLine();  

            Console.WriteLine("-------------------------------------------------------");  

            switch (mobileOperator)  
            {  
                case "1":  
                    mobileOperator = "Vodafone";  
                    break;  
                case "2":  
                    mobileOperator = "Airtel";  
                    break;  
                case "3":  
                    mobileOperator = "JIO";  
                    break;  
                default:  
                    break;  
            }  

            string message = mobileOperator + "*" + mobile + "*" + amount;  

            string scheme = "sb";  
            string serviceNamespace = "recharge";  
            string servicePath = "https://recharge.servicebus.windows.net/rechargerelay";  
            string policy = "RootManageSharedAccessKey";  
            string accessKey = "Kn1GO+dihGWMbMLEe6DfsuxJd6pEF6GivdY=";  

            ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;  

            var cf = new ChannelFactory<IRechargeChannel>(new NetTcpRelayBinding(),new EndpointAddress(ServiceBusEnvironment.CreateServiceUri(scheme, serviceNamespace,servicePath)));  

            cf.Endpoint.Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(policy, accessKey) });  

            using (var ch = cf.CreateChannel())  
            {  
                Console.WriteLine(ch.DoRecharge(message));  
            }  
        }  
    }  
}

• Run the WCF Client application.
• Provide required inputs and you can see the response returned from the WCF service.

We can find our WCF Client as listener under WCF Relays.

For demo purposes, we have created all the applications under a single solution, but in the real world, we can put WCF Service and Client on two different servers and verify how an external application (WCFClient) uses on-premise service, i.e., WCF Service through Relay.

Download the complete sample code from here .

This articles explains about Azure Service Bus Topic and Subscription which is commonly known as pub-sub with a real world scenario.

Business Requirement

The business requirement is in my previous article,

Azure Service Bus - Working With Queue In A Real World Scenario

So far we have seen about mobile recharge where we have used queuing mechanism. Now a company wants to provide some offers on regular recharge. But how will registered users come to know about these offers?

So again the company has started looking for some solution and finally it has come up with the solution of Azure Service Bus - Topic. Topic works like pub-sub model where one is the publisher and there can be many subscribers for the same publisher. In our scenario the publisher will publish offers and subscribed users will get the offers immediately.

Now let's see the step by step implementation of the below to design a solution:

• Log in to the Azure portal via portal.azure.com
• Explore previously created Service Namespace; i.e. Mobile Recharge
• Click on '+Topic' under Topics to create a new topic

• Give appropriate name for Topic
• Keep the rest of the input values as is and click on 'Create' button

We can see that Topic is created in it is shown under topics list.

• Click on previously created topic; i.e. 'Offers', which will show the list of subscriptions. As of now it shows empty
• Click on '+Subscription' under subscriptions to create subscription

• Give proper name of subscription
• Change Lock duration to 5 minutes and click on 'Create' button, which will create subscription for topic

• Follow the preceding steps and create one more subscription

We can see both the subscriptions in the list.

Credentials Click on 'Shared access policies' from the left panel, click on 'RootManageSharedAccessKey' to explore keys and connection strings which will be used further to connect.

Publish Message

• Create a console application in Visual Studio
• Set variables, one for connection string which you can copy from Shared access policies section and another is topic name; i.e. offers
• In order to publish the offers, we need an offer from user
• Add Microsoft.Azure.ServiceBus from a NuGet package manager
• Create topic client using connection string and queue name
• Convert string message to Azure Service Bus message
• Using topic client, call SendAsync method to publish the message.
• Call CloseAsync to close opened connection in finally block.

 class Program  
        {  
            static ITopicClient topicClient;  
            static void Main(string[] args)  
            {  
                string sbConnectionString = "Endpoint=sb://mobilerecharge.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=KVb9ubc9XaV0dT/1dMjW9CzPWvA/JGvVvUZ64U21IBI=";  
                string sbTopic = "offers";  

                string messageBody=string.Empty;  
                try  
                {  
                    Console.WriteLine("-------------------------------------------------------");  
                    Console.WriteLine("Publish Offer");  
                    Console.WriteLine("-------------------------------------------------------");  
                    Console.WriteLine("Offers");  
                    Console.WriteLine("1. Recharge with 100 and get talk time of 110");  
                    Console.WriteLine("2. Get 5 GB data on recharge of 300. Validity 28 days");  
                    Console.WriteLine("3. 1000 SMS in recharge of 100");  
                    Console.WriteLine("-------------------------------------------------------");  

                    Console.WriteLine("Offer:");  
                    string offer = Console.ReadLine();  

                    Console.WriteLine("-------------------------------------------------------");  

                    switch (offer)  
                    {  
                        case "1":  
                            offer = "Recharge with 100 and get talk time of 110";  
                            break;  
                        case "2":  
                            offer = "Get 5 GB data on recharge of 300. Validity 28 days";  
                            break;  
                        case "3":  
                            offer = "1000 SMS in recharge of 100";  
                            break;  
                        default:  
                            break;  
                    }  

                    messageBody = offer;  
                    topicClient = new TopicClient(sbConnectionString, sbTopic);  

                    var message = new Message(Encoding.UTF8.GetBytes(messageBody));  
                    Console.WriteLine($"Message Published: {messageBody}");  

                    topicClient.SendAsync(message);  

                }  
                catch (Exception ex)  
                {  
                    Console.WriteLine(ex.Message);  
                }  
                finally  
                {  
                    Console.ReadKey();  
                    topicClient.CloseAsync();  
                }  
            }  
        }

• Run the application and select the offer which you would like to publish
• You can see the published message 'Message Published…'

We can see that published message is added in all available subscriptions.

Read message from subscription

• Create a console application in the Visual Studio
• Set variables, one for connection string which you can copy from Shared access policies section and another is topic name; i.e. offers
• Create topic client using connection string and queue name
• Using topic client, call RegisterMessageHandler which is used to receive messages continuously from the entity. It registers a message handler and begins a new thread to receive messages. This handler is waited on every time a new message is received by the receiver.
• Inside ReceiveMessageAsync, call CompleteAsync which completes a message using its lock token and deletes the message from the queue.

    class Program  
        {  
            static ISubscriptionClient subscriptionClient;  
            static void Main(string[] args)  
            {  
                string sbConnectionString = "Endpoint=sb://mobilerecharge.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=KVb9ubc9XaV0dT/1dMjW9CzPWvA/JGvVvUZ64U21IBI=";  
                string sbTopic = "offers";  
                string sbSubscription = "akki5677";  
                try  
                {  
                    subscriptionClient = new SubscriptionClient(sbConnectionString, sbTopic, sbSubscription);  

                    var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)  
                    {  
                        MaxConcurrentCalls = 1,  
                        AutoComplete = false  
                    };  
                    subscriptionClient.RegisterMessageHandler(ReceiveMessagesAsync, messageHandlerOptions);  
                }  
                catch (Exception ex)  
                {  
                    Console.WriteLine(ex.Message);  
                }  
                finally  
                {  
                    Console.ReadKey();  
                    subscriptionClient.CloseAsync();  
                }  
            }  

            static async Task ReceiveMessagesAsync(Message message, CancellationToken token)  
            {  
                Console.WriteLine($"Subscribed message: {Encoding.UTF8.GetString(message.Body)}");  

                await subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);  
            }  

            static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)  
            {  
                Console.WriteLine(exceptionReceivedEventArgs.Exception);  
                return Task.CompletedTask;  
            }  
        }

• Run the application and you can see the previously added message in the subscription.

Now if you closely observe message count for all available subscriptions, one of the subscriptions has a zero message count as we have already read from that subscription and another subscription shows 1 as a message count means we need to publish once and it will be available for all subscriptions and whom so ever is read that only will be deleted and for rest it will be as it is.

• Now run both the applications simultaneously and select the offer which you would like to publish
• You can observe that the message will be read by the second application immediately.

Azure service bus topic is very similar to Azure service bus queue, the difference is queue works on one to one; i.e. one sender and one receiver whereas topic works on one to many; i.e. One publisher and many subscribers.

Note: Download complete sample code from here .

Business Requirement

One of the utility bill payments company wants to build an application, which will do the mobile recharge for end users. The application should support all the operators which are available in the market. The flow is, the user sends SMS in predefined format and application should parse the message and do the recharge accordingly.

Now, the biggest challenge is the application gets a huge number of recharge requests during the peak hours and is not able to process each request, so the company is looking for something like where all the requests are parked when they come and process one by one.

Azure Service Bus

The company came to know about the Azure Service Bus provided by Azure, so he started exploring Azure Service Bus.

Azure Service Bus supports cloud-based message-oriented middleware technologies like Queue, Topic, and Relay.

Here in order to meet the business requirement, we will use the queue mechanism where all the requests will be added in the queue and another side queue listener will process the message by reading from the queue.

Queue

The sender sends the message, adds it into the queue and the receiver processes the message in a FIFO (First In First Out) manner. The benefit of using queue is, it creates decoupling between sender and receiver, means sender and receiver should not be available at the same time while sending the message as messages are stored in a queue. Another benefit is load leveling, which means sender sends messages at a different rate and the receiver can process messages at a different rate, as both are independent in sending and processing.

Now let's see the step by step implementation of the below to design a solution:

1. Create Service Bus Namespace
2. Create Queue
3. Add a message in the queue
4. Read Message from the queue
5. Scheduled Message
6. Receive Mode
7. Abandoned Async
8. Dead-letter Queue

Create Service Bus Namespace

Service bus namespace is a container for all messaging components. One namespace contains multiple queues and topics.

• Log in to the Azure portal via portal.azure.com
• Click on 'Create a resource' from the left navigation pane, click on 'Integration' and then 'Service Bus'.

• Enter the proper name for a namespace
• Select pricing tier, for demo purpose we have selected Basic
• Subscription and Resource group, keep it as it is
• Select your desired location and click on 'Create' button

Once you create a namespace, you can explore the same from the dashboard where you can find all the details which you have provided while creating a namespace.

Credentials

Click on 'Shared access policies' from the left panel, click on 'RootManageSharedAccessKey' to explore keys and connection strings which will be used further to connect.

Create Queue

• Click on 'Mobile Recharge' namespace on Dashboard
• Click on 'Queues' on the left pane and click on '+Queue' to create new Queue.

• Enter queue name and click on 'Create' button keeping the rest of the input as it is.

• Click on 'Queues' and you will get a list of created queues. You can also find our recently created queue; i.e. recharge.

Add Message in the QUEUE

• Create a console application in Visual Studio
• Set variables, one for connection string which you can copy from Shared access policies section and another is queue name; i.e. recharge
• In order to do the recharge, we need a mobile number, amount and operator from user
• Concatenate preceding three values separated with a star(*)
• Add Microsoft.Azure.ServiceBus from a NuGet package manager
• Create queue client using connection string and queue name
• Convert string message to Azure Service Bus message
• Using queue client, call SendAsync method to add a message in the queue.
• Call CloseAsync to close opened connection in finally block.

    class Program  
        {  
            static QueueClient queueClient;  
            static void Main(string[] args)  
            {  
                string sbConnectionString = "Endpoint=sb://mobilerecharge.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=KVb9ubc9XaV0dT/1dMj/JGvVvUZ64U21IBI=";  
                string sbQueueName = "Recharge";  

                string messageBody=string.Empty;  
                try  
                {  
                    Console.WriteLine("-------------------------------------------------------");  
                    Console.WriteLine("Mobile Recharge");  
                    Console.WriteLine("-------------------------------------------------------");  
                    Console.WriteLine("Operators");  
                    Console.WriteLine("1. Vodafone");  
                    Console.WriteLine("2. Airtel");  
                    Console.WriteLine("3. JIO");  
                    Console.WriteLine("-------------------------------------------------------");  

                    Console.WriteLine("Operator:");  
                    string mobileOperator = Console.ReadLine();  
                    Console.WriteLine("Amount:");  
                    string amount = Console.ReadLine();  
                    Console.WriteLine("Mobile:");  
                    string mobile = Console.ReadLine();  

                    Console.WriteLine("-------------------------------------------------------");  

                    switch (mobileOperator)  
                    {  
                        case "1":  
                            mobileOperator = "Vodafone";  
                            break;  
                        case "2":  
                            mobileOperator = "Airtel";  
                            break;  
                        case "3":  
                            mobileOperator = "JIO";  
                            break;  
                        default:  
                            break;  
                    }  

                    messageBody = mobileOperator + "*" + mobile + "*" + amount;  
                    queueClient = new QueueClient(sbConnectionString, sbQueueName);  

                    var message = new Message(Encoding.UTF8.GetBytes(messageBody));  
                    Console.WriteLine($"Message Added in Queue: {messageBody}");  
                    queueClient.SendAsync(message);  


                }  
                catch (Exception ex)  
                {  
                    Console.WriteLine(ex.Message);  
                }  
                finally  
                {  
                    Console.ReadKey();  
                    queueClient.CloseAsync();  
                }  
            }  
        }

• Run the application and provide the required inputs
• You can see the message 'Message Added in Queue…'

• To check the added message in the portal, explore all the queues
• Click on the queue in which we have added the message i.e. 'Recharge'
• We can see 'Active message count' as 1

Read Message from QUEUE

• Create a console application in the Visual Studio
• Set variables, one for connection string which you can copy from Shared access policies section and another is queue name; i.e. recharge
• Create queue client using connection string and queue name
• Using queue client, call RegisterMessageHandler which is used to receive messages continuously from the entity. Registers a message handler and begins a new thread to receive messages. This handler has waited every time a new message is received by the receiver.
• Inside ReceiveMessageAsync, call CompleteAsync which completes a message using its lock token and deletes the message from the queue.

class Program  
    {  
        static QueueClient queueClient;  
        static void Main(string[] args)  
        {  
            string sbConnectionString = "Endpoint=sb://mobilerecharge.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=KVb9ubc9XaV0dT/1dMj/JGvVvUZ64U21IBI=";  
            string sbQueueName = "Recharge";  

            try  
            {  
                queueClient = new QueueClient(sbConnectionString, sbQueueName);  

                var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)  
                {  
                    MaxConcurrentCalls = 1,  
                    AutoComplete = false  
                };  
                queueClient.RegisterMessageHandler(ReceiveMessagesAsync, messageHandlerOptions);  
            }  
            catch (Exception ex)  
            {  
                Console.WriteLine(ex.Message);  
            }  
            finally  
            {  
                Console.ReadKey();  
                queueClient.CloseAsync();  
            }  
        }  

        static async Task ReceiveMessagesAsync(Message message, CancellationToken token)  
        {  
            Console.WriteLine($"Received message: {Encoding.UTF8.GetString(message.Body)}");  

            await queueClient.CompleteAsync(message.SystemProperties.LockToken);  
        }  

        static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)  
        {  
            Console.WriteLine(exceptionReceivedEventArgs.Exception);  
            return Task.CompletedTask;  
        }  
    }

• Run the application and you can see the previously added message in the queue.

• Check the queue once again in the portal and you can see the 'Active message count' as zero(0) as it was deleted by CompleteAsync.

• Now run both the applications simultaneously and provide the required inputs
• You can observe that the message will be read by the second application immediately.

Scheduled Message Now let's tweak the requirement, where we want to do recharge after a specific time, not now. So for this, we have scheduled message facility where you can schedule a message for a specific time. In the demo, we will set it after 5 minutes.

In order to implement this, we need to comment SendSync method and call ScheduleMessageAsync which expects a message and schedule time.

Modify your code as below,

DateTimeOffset scheduleTime = DateTime.UtcNow.AddMinutes(5);  
queueClient.ScheduleMessageAsync(message,scheduleTime);

• Run your application once again
• Provide required inputs

We can observe in the portal that the message is not added in the queue as 'Active message count' is zero (0) only.

Now wait for 5 minutes and verify once again in a portal. We can see that it's added as 5 minutes have passed.

Run the read application and you can get the scheduled message.

Receive Mode In the next step after receiving the message, you need to process that message; i.e. need to do a recharge. Now assume that while processing the message some exception occurs, then we may lose the request completely. For this situation, we have a Receive Mode facility.

You can specify two different modes as Receive Mode:

• PeekLock
• Receive and Delete

PeekLock

In this mode, the message won't be deleted until you call CompleteAsync method, so while processing if any exception occurs, we don't lose the message.

• Run both the applications simultaneously in debug mode.
• Provide the required input, and read application shows the added message.

Let's check the message in the portal, ideally, it was read by read application, so it should not be there in the portal but as Receive Mode is Peeklock, the message will be there.

Execute CompleAsync method after processing the message.

We can see in the portal that the message is not available as we have already called CompleteAsync.

ReceiveAndDelete

In Receive and Delete mode, as soon as the message is read, it will be deleted from the queue.

• Run both applications simultaneously in debug mode.
• Provide the required input and read application shows the added message.

• Don't execute CompleAsync method, just hold the debug point there only.

• Now, verify the message in the portal, ideally, CompleAsync is not called, so the message should be there but as we set ReceiveAndDelete mode, the message is deleted as soon as it was read.

AbandonAsync

Now in your application, whenever an exception occurs during processing you want to reprocess the message again. For this, we have the facility of AbandonAsync.

AbandonAsync abandons a Message using a lock token, this will make the message available again for processing.

To verify this we need to throw an exception explicitly from ReceiveMessageAsync and from the catch block call AbandonAsync method.

    static async Task ReceiveMessagesAsync(Message message, CancellationToken token)  
            {  
                try  
                {  
                    Console.WriteLine($"Received message: {Encoding.UTF8.GetString(message.Body)}");  

                    int i = 0;  
                    i=i / Convert.ToInt32(message);  

                    await queueClient.CompleteAsync(message.SystemProperties.LockToken);  
                }  
                catch(Exception ex)  
                {  
                   await queueClient.AbandonAsync(message.SystemProperties.LockToken);  
                }  
            }

Run the application once again and from the read application we can observe that the same message was read 10 times, this means whenever an exception occurs it was available once again to process.

You can configure the reprocess count from properties by setting Maximum Delivery Count. Previously it was read 10 times because, by default, Maximum Delivery Count is set to 10.

Once the 10-time process is over, it is no longer available in the queue, and it will be added in the Dead-letter queue. We can verify the same thing in the portal.

Dead-letter Queue

Now, in order to read the messages from the Dead-letter queue for analyzing purposes, the same application is used, you just need to change the queue name as below:

  string sbQueueName = "Recharge/$DeadLetterQueue";

Run the application and it will read all messages available in Dead-letter queue.

We don't find any messages in Dead-letter queue now.

In the next article, we will discuss Azure Service Bus - Topic.

Note: You can download the complete sample code from here .

Create an MVC project from the "Empty" template.

Right-click on "Controllers" and select "Add" >> "Controller...".

Select "MVC 5 Controller - Empty" to add an empty controller.

Click on the "Add" button.

Name the controller "HomeController".

The Index() action result method will be added.

To add a view, right-click on "Index" and select "Add View...".

Name the view and select "Empty (without model)" as the template. Click on the "Add" button.

We use the form attribute with the post method in our cshtml file. Inside the form attribute we have created a file upload and submit button. As our requirement is to upload multiple files, we need to set attribute multiple=multiple with file upload control.

Here in the HTTP post method, the uploaded file will be available as an HttpPostedFileBase parameter. HttpPostedFileBase serves as the base class for classes that provide access to individual files that have been uploaded by the client. That means we get only one file in this parameter.

So we use a request object. Using Request.Files we get all the posted files and store them in HttpFileCollectionBase. HttpFileCollectionBase serves as the base class for classes that provide access to files that were uploaded by a client. Once we have a collection of files, we iterate the collection and get each file one by one and assign them to HttpPostedFileBase.

Using HttpPostedFileBase we can have properties like ContentLength, ContentType, FileName and so on. First we get the physical path of our application using Server.MapPath and then save the file inside the images folder.

Now run the project and click on the "Choose File" button. Select the multiple files that you want to upload from your directory structure.

It will show the number of selected files with the "Choose Files" button. Now press the "Upload" button.

All the files are uploaded and you can see the files in the browser.

We can also check the existence of these files in the images folder.

Open Visual Studio and create a new project.

Select the API as the template and click OK.

Create an IShoppingcart Interface having GetCart method.

    namespace MultipleImplementation  
    {  
        public interface IShoppingCart  
        {  
            object GetCart();  
        }  
    }

Implement the GetCart method of IShoppingCart interface in ShoppingCartCache.

namespace MultipleImplementation  
{  
    public class ShoppingCartCache : IShoppingCart  
    {  
        public object GetCart()  
        {  
            return "Cart loaded from cache.";  
        }  
    }  
}

Implement the same interface in ShoppingCartDB.

namespace MultipleImplementation  
{  
    public class ShoppingCartDB : IShoppingCart  
    {  
        public object GetCart()  
        {  
            return "Cart loaded from DB";  
        }  
    }  
}

At last, implement the same interface in ShoppingCartAPI.

namespace MultipleImplementation  
{  
    public class ShoppingCartAPI : IShoppingCart  
    {  
        public object GetCart()  
        {  
            return "Cart loaded through API.";  
        }  
    }  
}

Now, we need a repository which will internally decide which implementation should be instantiated and called to get the GetCart method from it. So, create IShoppingCartRepository having the GetCart method.

namespace MultipleImplementation  
{  
    public interface IShoppingCartRepository  
    {  
        object GetCart();  
    }  
}

Create an enum to select the concrete implementation type, i.e, Cache, DB, or API.

namespace MultipleImplementation  
{  
    public class Constants  
    {  
    }  

    public enum CartSource  
    {  
        Cache=1,  
        DB=2,  
        API=3  
    }  
}

In the implementation of IShoppingCartRepository, we use constructor injection and we take Func delegate as a parameter. Func delegate expects a string as parameter and IShoppingCart as a return value. So in the GetCart method, you can see that we are using an enum to pass the parameter value which indicates the type of implementation we want to instantiate.

using System;  

namespace MultipleImplementation  
{  
    public class ShoppingCartRepository : IShoppingCartRepository  
    {  
        private readonly Func<string, IShoppingCart> shoppingCart;  
        public ShoppingCartRepository(Func<string, IShoppingCart> shoppingCart)  
        {  
            this.shoppingCart = shoppingCart;  
        }  

        public object GetCart()  
        {  
            return shoppingCart(CartSource.DB.ToString()).GetCart();  
        }  
    }  
}

In the same way, we need to add Func in startup class. First, we add the concrete implementation in service collection and on each request based on the parameter value, we used to get that concrete class.

using Microsoft.AspNetCore.Builder;  
using Microsoft.AspNetCore.Hosting;  
using Microsoft.Extensions.Configuration;  
using Microsoft.Extensions.DependencyInjection;  
using System;  

namespace MultipleImplementation  
{  
    public class Startup  
    {  
        public Startup(IConfiguration configuration)  
        {  
            Configuration = configuration;  
        }  

        public IConfiguration Configuration { get; }  

        public void ConfigureServices(IServiceCollection services)  
        {  

            services.AddScoped<IShoppingCartRepository, ShoppingCartRepository>();  

            services.AddSingleton<ShoppingCartCache>();  
            services.AddSingleton<ShoppingCartDB>();  
            services.AddSingleton<ShoppingCartAPI>();  

            services.AddTransient<Func<string, IShoppingCart>>(serviceProvider => key =>  
            {  
                switch (key)  
                {  
                    case "API":  
                        return serviceProvider.GetService<ShoppingCartAPI>();  
                    case "DB":  
                        return serviceProvider.GetService<ShoppingCartDB>();  
                    default:  
                        return serviceProvider.GetService<ShoppingCartCache>();  
                }  
            });  

            services.AddMvc();  
        }  

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)  
        {  
            if (env.IsDevelopment())  
            {  
                app.UseDeveloperExceptionPage();  
            }  

            app.UseMvc();  
        }  
    }  
}

You can download the sample from here.

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title></title>
</head>
<body>
    <script id="javascript">
        for (var i = 0; i < 5; i++) 
        {
            alert("Akshay " + i);
        }
    </script>
</body>
</html>