Working With Event Hub NET SDK

This guide demonstrates common patterns for using the Azure Event Hubs .NET SDK: creating producer and consumer clients, inspecting partitions, publishing event batches, and reading events. It includes short focused examples and a complete Program.cs sample you can run locally. Reference: Azure Event Hubs .NET SDK overview and Azure Event Hubs documentation. Quick summary (what you’ll learn)

How to instantiate EventHubProducerClient and examine partition IDs.
How to create an EventDataBatch, add events, and send them to an Event Hub.
How to instantiate EventHubConsumerClient and read events with a cancellation token.

Overview of primary SDK types

Resource / Type	Purpose	Typical usage example
`EventHubProducerClient`	Send events to an Event Hub and inspect partitions	`new EventHubProducerClient(connectionString, eventHubName)`
`EventDataBatch`	Pack multiple `EventData` instances into a batch that fits service limits	`producer.CreateBatchAsync()`
`EventData`	Represents a single event payload	`new EventData(new BinaryData("payload"))`
`EventHubConsumerClient`	Receive events from a consumer group	`new EventHubConsumerClient(consumerGroup, connectionString, eventHubName)`
`PartitionEvent`	A received event plus partition/context metadata	`await foreach (PartitionEvent e in consumer.ReadEventsAsync(...))`

Instantiating an Event Hub (inspect partitions) To connect and inspect partition information, create an EventHubProducerClient. Retrieving partition IDs with GetPartitionIdsAsync() helps you understand how messages will be distributed across partitions.

await using (var producer = new EventHubProducerClient(connectionString, eventHubName))
{
    string[] partitionIds = await producer.GetPartitionIdsAsync();
    // Partition IDs can be iterated or inspected to understand partition layout
}

Creating and sending a batch of events Batching is efficient and ensures the client respects the service-side size constraints. Create an EventDataBatch with CreateBatchAsync, add events via TryAdd, and then send the batch using SendAsync.

await using (var producer = new EventHubProducerClient(connectionString, eventHubName))
{
    using EventDataBatch eventBatch = await producer.CreateBatchAsync();
    eventBatch.TryAdd(new EventData(new BinaryData("First")));
    eventBatch.TryAdd(new EventData(new BinaryData("Second")));

    await producer.SendAsync(eventBatch);
    // The batch is now sent to the Event Hub
}

Reading events from an Event Hub Use an EventHubConsumerClient to read from a consumer group. ReadEventsAsync returns a stream of PartitionEvent instances. Use a CancellationTokenSource to limit how long the consumer listens.

string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;

await using (var consumer = new EventHubConsumerClient(consumerGroup, connectionString, eventHubName))
{
    using var cancellationSource = new CancellationTokenSource();
    cancellationSource.CancelAfter(TimeSpan.FromSeconds(45));

    await foreach (PartitionEvent receivedEvent in consumer.ReadEventsAsync(cancellationSource.Token))
    {
        // Process each received event
        Console.WriteLine("Event Received: " + receivedEvent.Data.EventBody.ToString());
    }
}

A complete example The consolidated Program.cs below demonstrates inspecting partitions, publishing a batch, and reading events. Replace connectionString with the connection string you copy from the Azure portal (either the Event Hubs namespace or hub-level SAS policy). Ensure the connection string you use has send and/or listen permissions as needed.

Make sure the connection string has the appropriate permissions (send and/or listen). Create a SAS policy at the Event Hub level or use the namespace-level RootManageSharedAccessKey if you need all permissions.

using System;
using System.Threading;
using System.Threading.Tasks;
using Azure.Messaging.EventHubs;
using Azure.Messaging.EventHubs.Producer;
using Azure.Messaging.EventHubs.Consumer;

class Program
{
    // Replace with your Event Hubs connection string and hub name
    private const string connectionString = "<EVENT_HUB_CONNECTION_STRING>";
    private const string eventHubName = "hub-01";
    private const string consumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;

    static async Task Main(string[] args)
    {
        await InspectEventHub();
        await PublishEventsToEventHub();
        await ReadEventsFromEventHub();
    }

    static async Task InspectEventHub()
    {
        Console.WriteLine("Inspecting Event Hub...");

        await using (var producer = new EventHubProducerClient(connectionString, eventHubName))
        {
            string[] partitionIds = await producer.GetPartitionIdsAsync();
            Console.WriteLine($"Found {partitionIds.Length} partition(s): {string.Join(", ", partitionIds)}");
        }
    }

    static async Task PublishEventsToEventHub()
    {
        Console.WriteLine("Publishing events to Event Hub...");

        await using (var producer = new EventHubProducerClient(connectionString, eventHubName))
        {
            using EventDataBatch eventBatch = await producer.CreateBatchAsync();

            eventBatch.TryAdd(new EventData(new BinaryData("Hello, let's learn Azure Event Hubs!")));
            eventBatch.TryAdd(new EventData(new BinaryData("Let's learn to send events to Event Hubs!")));

            await producer.SendAsync(eventBatch);
            Console.WriteLine("Events sent.");
        }
    }

    static async Task ReadEventsFromEventHub()
    {
        Console.WriteLine("Reading events from Event Hub...");

        await using (var consumer = new EventHubConsumerClient(consumerGroup, connectionString, eventHubName))
        {
            using var cancellationSource = new CancellationTokenSource();
            cancellationSource.CancelAfter(TimeSpan.FromSeconds(45));

            await foreach (PartitionEvent receivedEvent in consumer.ReadEventsAsync(cancellationSource.Token))
            {
                Console.WriteLine("Event Received: " + receivedEvent.Data.EventBody.ToString());
            }
        }
    }
}

Running the example

Build and run with dotnet run.
The program will:
1. List the Event Hub partition IDs.
2. Publish the two example events as a single batch.
3. Listen for incoming events for up to 45 seconds and print any that arrive.
If other producers (for example, an App Service configured to send to this hub) are sending messages, this consumer will receive them while it is listening.

Best practices and tips

Scope clients to the operation: create separate producer/consumer instances for distinct operations or lifetimes.
Use EventDataBatch to avoid exceeding service-side size limits when sending multiple events.
Always use a cancellation token when reading so the consumer doesn’t block indefinitely.
For production, consider using retry policies and proper error handling for transient failures.

Introduction

Exploring Azure App Service

Configuring Web App Settings

Scaling Apps in Azure App Service

Exploring App Service Deployment Slots

Exploring Azure Functions

Developing Azure Functions

Exploring Azure Blob Storage

Managing Azure Blob Storage Lifecycle

Working With Azure Blob Storage

Exploring Azure Cosmos DB

Working With Azure Cosmos DB

Managing Container Images in Azure Container Registry

Running Container Images in Azure Container Instances

Implementing Azure Container Apps

Exploring the Microsoft Identity Platform

Implementing Authentication Using MSAL

Implementing Shared Access Signatures

Exploring Microsoft Graph

Implementing Azure Key Vault

Implementing Managed Identities

Implementing Azure App Configuration

Exploring API Management

Exploring Azure Event Grid

Exploring Azure Event Hubs

Discovering Azure Message Queues

Monitoring App Performance

Developing Azure Cache for Redis

Developing for storage on CDNs

Working With Event Hub NET SDK

Watch Video

Practice Lab