DEV Community

Sardar Mudassar Ali Khan
Sardar Mudassar Ali Khan

Posted on

12

Azure Service Bus Integration With Asp.NET Core Web API Applications Complete Example Application

Sure! Below is an example of an ASP.NET Core application named "AzureBusServiceIntegration" that demonstrates how to integrate with Azure Service Bus. This example covers sending and receiving messages using Azure Service Bus Queue.

Step 1: Create a new ASP.NET Core Web Application
Create a new ASP.NET Core Web Application using Visual Studio or the .NET CLI with the following command:

dotnet new webapp -n AzureBusServiceIntegration
Enter fullscreen mode Exit fullscreen mode

Step 2: Install Required NuGet Packages
Add the necessary Azure Service Bus NuGet packages to the project. Open the .csproj file and add the following package references within the <ItemGroup> section:

<ItemGroup>
  <PackageReference Include="Microsoft.Azure.ServiceBus" Version="5.2.1" />
</ItemGroup>
Enter fullscreen mode Exit fullscreen mode

Step 3: Configure Azure Service Bus Connection String
In the appsettings.json file, add your Azure Service Bus connection string:

{
  "AzureServiceBus": {
    "ConnectionString": "your_service_bus_connection_string",
    "QueueName": "your_queue_name"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Step 4: Create AzureBusService Class
Create a class named AzureBusService.cs to encapsulate the logic for sending and receiving messages from the Azure Service Bus Queue:

using System;
using Microsoft.Azure.ServiceBus;
using Microsoft.Extensions.Configuration;
using System.Text;
using System.Threading.Tasks;

namespace AzureBusServiceIntegration.Services
{
    public class AzureBusService : IAzureBusService
    {
        private readonly IConfiguration _configuration;
        private readonly IQueueClient _queueClient;

        public AzureBusService(IConfiguration configuration)
        {
            _configuration = configuration;
            _queueClient = new QueueClient(_configuration["AzureServiceBus:ConnectionString"], _configuration["AzureServiceBus:QueueName"]);
        }

        public async Task SendMessageAsync(string message)
        {
            var encodedMessage = new Message(Encoding.UTF8.GetBytes(message));
            await _queueClient.SendAsync(encodedMessage);
        }

        public async Task ReceiveMessageAsync()
        {
            var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
            {
                MaxConcurrentCalls = 1,
                AutoComplete = false
            };

            _queueClient.RegisterMessageHandler(ProcessMessageAsync, messageHandlerOptions);
            await Task.CompletedTask; // Let the method run continuously
        }

        private async Task ProcessMessageAsync(Message message, CancellationToken token)
        {
            var messageBody = Encoding.UTF8.GetString(message.Body);
            Console.WriteLine($"Received message: {messageBody}");

            // You can process the message here as per your application's needs.

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

        private Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
        {
            Console.WriteLine($"Message handler encountered an exception: {exceptionReceivedEventArgs.Exception}");
            return Task.CompletedTask;
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Step 5: Create the IAzureBusService Interface
Create an interface named IAzureBusService.cs to define the methods used in the AzureBusService class:

using System.Threading.Tasks;

namespace AzureBusServiceIntegration.Services
{
    public interface IAzureBusService
    {
        Task SendMessageAsync(string message);
        Task ReceiveMessageAsync();
    }
}
Enter fullscreen mode Exit fullscreen mode

Step 6: Update Startup.cs
In the Startup.cs file, configure dependency injection for the IAzureBusService:

using AzureBusServiceIntegration.Services;

// ...

public void ConfigureServices(IServiceCollection services)
{
    // ...
    services.AddSingleton<IAzureBusService, AzureBusService>();
    // ...
}
Enter fullscreen mode Exit fullscreen mode

Step 7: Add Controllers
Create a new controller to send and receive messages. For example, create HomeController.cs:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using AzureBusServiceIntegration.Services;

namespace AzureBusServiceIntegration.Controllers
{
    public class HomeController : Controller
    {
        private readonly IAzureBusService _azureBusService;

        public HomeController(IAzureBusService azureBusService)
        {
            _azureBusService = azureBusService;
        }

        public async Task<IActionResult> Index()
        {
            await _azureBusService.SendMessageAsync("Hello, Azure Service Bus!");
            return View();
        }

        public async Task<IActionResult> Receive()
        {
            await _azureBusService.ReceiveMessageAsync();
            return Content("Receiving messages from Azure Service Bus Queue. Check the console output for received messages.");
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Step 8: Add Views
Create a basic view for the Index action in Views/Home/Index.cshtml:

@{
    ViewData["Title"] = "Home";
}

<h1>Welcome to Azure Service Bus Integration</h1>
<p>Click the button to send a message to Azure Service Bus Queue.</p>
<button type="button" onclick="location.href='@Url.Action("Index", "Home")'">Send Message</button>
Enter fullscreen mode Exit fullscreen mode

Step 9: Update Startup.cs
Update the Configure method in Startup.cs to set up routing and add the Receive action to receive messages:

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

namespace AzureBusServiceIntegration
{
    public class Startup
    {
        // ...

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            // ...
            app.UseRouting();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
                endpoints.MapControllers();
            });
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Step 10: Run the Application
Run the application, and you can navigate to the /Home route to send a message to the Azure Service Bus Queue. To start receiving messages, navigate to the /Home/Receive route. The received messages will be printed in the console.

Image of Timescale

🚀 pgai Vectorizer: SQLAlchemy and LiteLLM Make Vector Search Simple

We built pgai Vectorizer to simplify embedding management for AI applications—without needing a separate database or complex infrastructure. Since launch, developers have created over 3,000 vectorizers on Timescale Cloud, with many more self-hosted.

Read more →

Top comments (0)

Billboard image

The Next Generation Developer Platform

Coherence is the first Platform-as-a-Service you can control. Unlike "black-box" platforms that are opinionated about the infra you can deploy, Coherence is powered by CNC, the open-source IaC framework, which offers limitless customization.

Learn more