The main cause of the error is the Azure Event Hubs Emulator is unable to connect to Azure Blob Storage using the provided connection string, This leads to the emulator’s components (MetadataStore and BlobStore) being in an unhealthy state.

In the below compose file I have configured with the necessary environment variables that points to the Azure Blob Storage account.

I refered to this MSDOC to Use Azurite emulator for Azure Storage development in env.

Test locally by using the Azure Event Hubs emulator

Docker Compose:

version: '3.8'
services:
  emulator:
    image: "mcr.microsoft.com/azure-messaging/eventhubs-emulator:latest"
    container_name: "eventhubs-emulator"
    ports:
      - "5672:5672"  # AMQP port for the Event Hubs Emulator
      - "9091:9091"  # Management port for the Event Hubs Emulator
    environment:
      ACCEPT_EULA: "Y"
      BLOB_SERVER: azurite
      METADATA_SERVER: azurite
      AZURE_STORAGE_CONNECTION_STRING: "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFe6kVZk3+0h1t9SQGphf65SlPfuFU=;BlobEndpoint=http://azurite:10000/devstoreaccount1;QueueEndpoint=http://azurite:10001/devstoreaccount1;TableEndpoint=http://azurite:10002/devstoreaccount1;"
    depends_on:
      - azurite
    networks:
      - eh-emulator

  azurite:
    image: "mcr.microsoft.com/azure-storage/azurite:latest"
    container_name: "azurite"
    ports:
      - "10000:10000"  # Blob service
      - "10001:10001"  # Queue service
      - "10002:10002"  # Table service
    command: "azurite-blob --blobHost 0.0.0.0 --blobPort 10000"
    networks:
      - eh-emulator

networks:
  eh-emulator:
    driver: bridge

• Update the .csproj file to specify compatible versions.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Azure.Messaging.EventHubs" Version="5.12.0-beta.1" />
    <PackageReference Include="Azure.Messaging.EventHubs.Processor" Version="5.12.0-beta.1" />
  </ItemGroup>
</Project>

Copy the below emulator connection string.

Here is the code which work perfectly. Refered the code from Git.

using Azure.Messaging.EventHubs.Producer;
using Azure.Messaging.EventHubs;
using System.Text;
using Azure.Messaging.EventHubs.Consumer;
using Azure.Messaging.EventHubs.Processor;
using Azure.Storage.Blobs;
using System;

internal class Program
{
    private static string checkpointBlobContainer = Guid.NewGuid().ToString();

    // Ensure that this connection string is correct, and replace <YourSASKeyValue> with the actual SAS key.
    private static string eventHubNamespaceConnectionString = "Endpoint=sb://.t/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=obib9i9xxxxxxxxx";
    private static string eventHubName = "testevehub";

    public static async Task Main(string[] args)
    {
        try
        {
            // Sends a batch of events to the event hub
            await Send();

            // Receives events from the event hub
            await Receive();

            // Receives the same events from the event hub using an event processor
            await CreateCheckpointBlobForTests(checkpointBlobContainer);
            await ReceiveWithEventProcessor();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }

        Console.ReadKey();
    }

    private static async Task Send()
    {
        int numOfEvents = 2;

        // Initialize the Event Hub Producer Client
        EventHubProducerClient producerClient = new EventHubProducerClient(eventHubNamespaceConnectionString, eventHubName);

        using EventDataBatch eventBatch = await producerClient.CreateBatchAsync();

        for (int i = 1; i <= numOfEvents; i++)
        {
            if (!eventBatch.TryAdd(new EventData(Encoding.UTF8.GetBytes($"Event {i}"))))
            {
                throw new Exception($"Event {i} is too large for the batch and cannot be sent.");
            }
        }

        try
        {
            await producerClient.SendAsync(eventBatch);
            Console.WriteLine($"A batch of {numOfEvents} events has been published.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to send events: {ex.Message}");
        }
        finally
        {
            await producerClient.DisposeAsync();
        }
    }

    private static async Task Receive()
    {
        try
        {
            var consumer = new EventHubConsumerClient(EventHubConsumerClient.DefaultConsumerGroupName, eventHubNamespaceConnectionString, eventHubName);

            await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(new ReadEventOptions { MaximumWaitTime = TimeSpan.FromSeconds(2) }))
            {
                if (partitionEvent.Data != null)
                {
                    string messageBody = Encoding.UTF8.GetString(partitionEvent.Data.Body.ToArray());
                    Console.WriteLine($"Message received : '{messageBody}'");
                }
                else
                {
                    break;
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to receive events: {ex.Message}");
        }
    }

    private static async Task ReceiveWithEventProcessor()
    {
        try
        {
            // Blob storage connection string points to Azurite emulator for local testing
            BlobContainerClient blobContainerClient = new BlobContainerClient("UseDevelopmentStorage=true", checkpointBlobContainer);

            // Create an event processor client to process events in the event hub
            var processor = new EventProcessorClient(blobContainerClient, EventHubConsumerClient.DefaultConsumerGroupName, eventHubNamespaceConnectionString, eventHubName);

            // Register handlers for processing events and handling errors
            processor.ProcessEventAsync += ProcessEventHandler;
            processor.ProcessErrorAsync += ProcessErrorHandler;

            // Start the processing
            await processor.StartProcessingAsync();

            // Wait for 10 seconds for the events to be processed
            await Task.Delay(TimeSpan.FromSeconds(10));

            // Stop the processing
            await processor.StopProcessingAsync();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in event processor: {ex.Message}");
        }
    }

    private static Task ProcessEventHandler(ProcessEventArgs eventArgs)
    {
        try
        {
            Console.WriteLine("Received event using Event Processor: {0}", Encoding.UTF8.GetString(eventArgs.Data.Body.ToArray()));
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error processing event: {ex.Message}");
        }
        return Task.CompletedTask;
    }

    private static Task ProcessErrorHandler(ProcessErrorEventArgs eventArgs)
    {
        Console.WriteLine($"tPartition '{eventArgs.PartitionId}': an unhandled exception was encountered. This was not expected to happen.");
        Console.WriteLine($"Error message: {eventArgs.Exception.Message}");
        return Task.CompletedTask;
    }

    private static async Task CreateCheckpointBlobForTests(string blobContainerName)
    {
        try
        {
            BlobServiceClient client = new BlobServiceClient("UseDevelopmentStorage=true");
            await client.CreateBlobContainerAsync(blobContainerName);
            Console.WriteLine($"Created checkpoint blob container: {blobContainerName}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error creating checkpoint blob: {ex.Message}");
        }
    }
}

Now Iam able to connect with event hub with the application.

Containers:

Able to recieve the sent messages.