Azure Eventgrid Dotnet

using Azure;using Azure.Messaging.EventGrid;
EventGridPublisherClient client = new(    new Uri("https://mytopic.eastus-1.eventgrid.azure.net/api/events"),    new AzureKeyCredential("<access-key>"));

using Azure.Identity;using Azure.Messaging.EventGrid;
// Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>var credential = new DefaultAzureCredential(    DefaultAzureCredential.DefaultEnvironmentVariableName);// Or use a specific credential directly in production:// See https://learn.microsoft.com/dotnet/api/overview/azure/identity-readme?view=azure-dotnet#credential-classes// var credential = new ManagedIdentityCredential();EventGridPublisherClient client = new(    new Uri("https://mytopic.eastus-1.eventgrid.azure.net/api/events"),    credential);

string sasToken = EventGridPublisherClient.BuildSharedAccessSignature(    new Uri(topicEndpoint),    DateTimeOffset.UtcNow.AddHours(1),    new AzureKeyCredential(topicKey));
var sasCredential = new AzureSasCredential(sasToken);EventGridPublisherClient client = new(    new Uri(topicEndpoint),    sasCredential);

EventGridPublisherClient client = new(    new Uri(topicEndpoint),    new AzureKeyCredential(topicKey));
// Single eventEventGridEvent egEvent = new(    subject: "orders/12345",    eventType: "Order.Created",    dataVersion: "1.0",    data: new { OrderId = "12345", Amount = 99.99 });
await client.SendEventAsync(egEvent);
// Batch of eventsList<EventGridEvent> events = new(){    new EventGridEvent(        subject: "orders/12345",        eventType: "Order.Created",        dataVersion: "1.0",        data: new OrderData { OrderId = "12345", Amount = 99.99 }),    new EventGridEvent(        subject: "orders/12346",        eventType: "Order.Created",        dataVersion: "1.0",        data: new OrderData { OrderId = "12346", Amount = 149.99 })};
await client.SendEventsAsync(events);

CloudEvent cloudEvent = new(    source: "/orders/system",    type: "Order.Created",    data: new { OrderId = "12345", Amount = 99.99 });
cloudEvent.Subject = "orders/12345";cloudEvent.Id = Guid.NewGuid().ToString();cloudEvent.Time = DateTimeOffset.UtcNow;
await client.SendEventAsync(cloudEvent);
// Batch of CloudEventsList<CloudEvent> cloudEvents = new(){    new CloudEvent("/orders", "Order.Created", new { OrderId = "1" }),    new CloudEvent("/orders", "Order.Updated", new { OrderId = "2" })};
await client.SendEventsAsync(cloudEvents);

// Events must specify the Topic property for domain routingList<EventGridEvent> events = new(){    new EventGridEvent(        subject: "orders/12345",        eventType: "Order.Created",        dataVersion: "1.0",        data: new { OrderId = "12345" })    {        Topic = "orders-topic"  // Domain topic name    },    new EventGridEvent(        subject: "inventory/item-1",        eventType: "Inventory.Updated",        dataVersion: "1.0",        data: new { ItemId = "item-1" })    {        Topic = "inventory-topic"    }};
await client.SendEventsAsync(events);

using System.Text.Json;
var serializerOptions = new JsonSerializerOptions{    PropertyNamingPolicy = JsonNamingPolicy.CamelCase};
var customSerializer = new JsonObjectSerializer(serializerOptions);
EventGridEvent egEvent = new(    subject: "orders/12345",    eventType: "Order.Created",    dataVersion: "1.0",    data: customSerializer.Serialize(new OrderData { OrderId = "12345" }));
await client.SendEventAsync(egEvent);

using Azure;using Azure.Messaging;using Azure.Messaging.EventGrid.Namespaces;
var senderClient = new EventGridSenderClient(    new Uri(namespaceEndpoint),    topicName,    new AzureKeyCredential(topicKey));
// Send single eventCloudEvent cloudEvent = new("employee_source", "Employee.Created",     new { Name = "John", Age = 30 });await senderClient.SendAsync(cloudEvent);
// Send batchawait senderClient.SendAsync(new[]{    new CloudEvent("source", "type", new { Name = "Alice" }),    new CloudEvent("source", "type", new { Name = "Bob" })});

var receiverClient = new EventGridReceiverClient(    new Uri(namespaceEndpoint),    topicName,    subscriptionName,    new AzureKeyCredential(topicKey));
// Receive eventsReceiveResult result = await receiverClient.ReceiveAsync(maxEvents: 10);
List<string> lockTokensToAck = new();List<string> lockTokensToRelease = new();
foreach (ReceiveDetails detail in result.Details){    CloudEvent cloudEvent = detail.Event;    string lockToken = detail.BrokerProperties.LockToken;        try    {        // Process the event        Console.WriteLine($"Event: {cloudEvent.Type}, Data: {cloudEvent.Data}");        lockTokensToAck.Add(lockToken);    }    catch (Exception)    {        // Release for retry        lockTokensToRelease.Add(lockToken);    }}
// Acknowledge successfully processed eventsif (lockTokensToAck.Any()){    await receiverClient.AcknowledgeAsync(lockTokensToAck);}
// Release events for retryif (lockTokensToRelease.Any()){    await receiverClient.ReleaseAsync(lockTokensToRelease);}

// Reject events that cannot be processedawait receiverClient.RejectAsync(new[] { lockToken });

using Azure.Messaging.EventGrid;using Microsoft.Azure.WebJobs;using Microsoft.Azure.WebJobs.Extensions.EventGrid;
public static class EventGridFunction{    [FunctionName("ProcessEventGridEvent")]    public static void Run(        [EventGridTrigger] EventGridEvent eventGridEvent,        ILogger log)    {        log.LogInformation($"Event Type: {eventGridEvent.EventType}");        log.LogInformation($"Subject: {eventGridEvent.Subject}");        log.LogInformation($"Data: {eventGridEvent.Data}");    }}

using Azure.Messaging;using Microsoft.Azure.Functions.Worker;
public class CloudEventFunction{    [Function("ProcessCloudEvent")]    public void Run(        [EventGridTrigger] CloudEvent cloudEvent,        FunctionContext context)    {        var logger = context.GetLogger("ProcessCloudEvent");        logger.LogInformation($"Event Type: {cloudEvent.Type}");        logger.LogInformation($"Source: {cloudEvent.Source}");        logger.LogInformation($"Data: {cloudEvent.Data}");    }}

// From JSON stringstring json = "..."; // Event Grid webhook payloadEventGridEvent[] events = EventGridEvent.ParseMany(BinaryData.FromString(json));
foreach (EventGridEvent egEvent in events){    if (egEvent.TryGetSystemEventData(out object systemEvent))    {        // Handle system event        switch (systemEvent)        {            case StorageBlobCreatedEventData blobCreated:                Console.WriteLine($"Blob created: {blobCreated.Url}");                break;        }    }    else    {        // Handle custom event        var customData = egEvent.Data.ToObjectFromJson<MyCustomData>();    }}

CloudEvent[] cloudEvents = CloudEvent.ParseMany(BinaryData.FromString(json));
foreach (CloudEvent cloudEvent in cloudEvents){    var data = cloudEvent.Data.ToObjectFromJson<MyEventData>();    Console.WriteLine($"Type: {cloudEvent.Type}, Data: {data}");}

// Common system event typesusing Azure.Messaging.EventGrid.SystemEvents;
// Storage eventsStorageBlobCreatedEventData blobCreated;StorageBlobDeletedEventData blobDeleted;
// Resource eventsResourceWriteSuccessEventData resourceCreated;ResourceDeleteSuccessEventData resourceDeleted;
// App Service eventsWebAppUpdatedEventData webAppUpdated;
// Container Registry eventsContainerRegistryImagePushedEventData imagePushed;
// IoT Hub eventsIotHubDeviceCreatedEventData deviceCreated;

using Azure;
try{    await client.SendEventAsync(cloudEvent);}catch (RequestFailedException ex) when (ex.Status == 401){    Console.WriteLine("Authentication failed - check credentials");}catch (RequestFailedException ex) when (ex.Status == 403){    Console.WriteLine("Authorization failed - check RBAC permissions");}catch (RequestFailedException ex) when (ex.Status == 413){    Console.WriteLine("Payload too large - max 1MB per event, 1MB total batch");}catch (RequestFailedException ex){    Console.WriteLine($"Event Grid error: {ex.Status} - {ex.Message}");}

try{    var primaryClient = new EventGridPublisherClient(primaryUri, primaryKey);    await primaryClient.SendEventsAsync(events);}catch (RequestFailedException){    // Failover to secondary region    var secondaryClient = new EventGridPublisherClient(secondaryUri, secondaryKey);    await secondaryClient.SendEventsAsync(events);}