I've spent years building applications that scale from zero to millions of users, and serverless computing changed everything. Before Azure Functions, scaling meant provisioning servers, managing load balancers, and dealing with infrastructure that sat idle during low traffic. Serverless flipped this model-now you write code, deploy it, and Azure handles everything else.
For C# developers, Azure Functions represents the natural evolution of our cloud journey. It combines the familiarity of .NET with the power of serverless computing, enabling event-driven architectures that scale automatically and cost nothing when idle. This isn't just about saving money-it's about building systems that respond instantly to business events.
In this comprehensive guide, we'll explore Azure Functions from the ground up. You'll learn how to build scalable, event-driven applications using triggers, bindings, and durable functions. We'll cover everything from basic HTTP endpoints to complex workflows, with practical patterns you can apply immediately.
By the end, you'll understand why serverless computing is more than a trend-it's the foundation of modern cloud-native applications.
Why Serverless Matters for C# Developers
The first time I deployed an Azure Function, I was skeptical. "How can this replace a full web application?" I wondered. But after seeing it handle thousands of requests per second while costing pennies, I was converted.
Serverless computing offers compelling advantages: - Automatic scaling: Functions scale from zero to thousands of instances instantly - Pay-per-execution: You only pay for actual compute time, not idle servers - Event-driven: Functions respond to events from queues, databases, and external services - Managed infrastructure: Azure handles patching, scaling, and reliability - Developer productivity: Focus on business logic, not infrastructure
For C# developers, this means using familiar tools and patterns while benefiting from cloud-native capabilities. The same dependency injection, logging, and testing practices work in serverless as they do in traditional applications.
Your First Azure Function: Hello World with C#
Let's start with the fundamentals. We'll create a simple HTTP-triggered function that demonstrates the core concepts without overwhelming complexity.
// Program.cs - Entry point for Azure Functions
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Hosting;
var host = new HostBuilder()
.ConfigureFunctionsWorkerDefaults()
.Build();
host.Run();
// HttpFunction.cs - HTTP-triggered function
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;
using System.Text.Json;
namespace Ecommerce.Functions
{
public class OrderFunctions
{
private readonly ILogger _logger;
public OrderFunctions(ILogger logger)
{
_logger = logger;
}
[Function("CreateOrder")]
public async Task<HttpResponseData> CreateOrder(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "orders")] HttpRequestData req,
FunctionContext executionContext)
{
_logger.LogInformation("Processing order creation request");
try
{
// Read request body
var requestBody = await req.ReadAsStringAsync();
var orderRequest = JsonSerializer.Deserialize<CreateOrderRequest>(requestBody);
// Validate request
if (orderRequest == null || string.IsNullOrEmpty(orderRequest.CustomerId))
{
var badResponse = req.CreateResponse(HttpStatusCode.BadRequest);
await badResponse.WriteStringAsync("Invalid order request - CustomerId is required");
return badResponse;
}
// Create order
var order = new Order
{
Id = Guid.NewGuid().ToString(),
CustomerId = orderRequest.CustomerId,
Items = orderRequest.Items ?? new List<OrderItem>(),
Total = orderRequest.Items?.Sum(item => item.UnitPrice * item.Quantity) ?? 0,
Status = OrderStatus.Pending,
CreatedAt = DateTime.UtcNow
};
// In a real app, you'd save to database here
_logger.LogInformation($"Created order {order.Id} for customer {order.CustomerId}");
// Return response
var response = req.CreateResponse(HttpStatusCode.Created);
await response.WriteAsJsonAsync(new
{
orderId = order.Id,
status = order.Status.ToString(),
total = order.Total
});
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error processing order creation");
var errorResponse = req.CreateResponse(HttpStatusCode.InternalServerError);
await errorResponse.WriteStringAsync("An error occurred processing your request");
return errorResponse;
}
}
}
// Data models
public class CreateOrderRequest
{
public string CustomerId { get; set; }
public List<OrderItem> Items { get; set; }
}
public class OrderItem
{
public string ProductId { get; set; }
public int Quantity { get; set; }
public decimal UnitPrice { get; set; }
}
public class Order
{
public string Id { get; set; }
public string CustomerId { get; set; }
public List<OrderItem> Items { get; set; }
public decimal Total { get; set; }
public OrderStatus Status { get; set; }
public DateTime CreatedAt { get; set; }
}
public enum OrderStatus
{
Pending,
Processing,
Confirmed,
Shipped,
Delivered,
Cancelled
}
} This function demonstrates key Azure Functions concepts: dependency injection, proper error handling, and structured logging. The isolated process model ensures each function runs independently.
Let's create the project structure and configuration files.
# Ecommerce.Functions.csproj
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<AzureFunctionsVersion>v4</AzureFunctionsVersion>
<OutputType>Exe</OutputType>
<ImplicitUsings>enabled</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.21.0" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.16.4" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Http" Version="3.1.0" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Storage" Version="6.3.0" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.ApplicationInsights" Version="1.1.0" />
</ItemGroup>
<ItemGroup>
<None Update="host.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Update="local.settings.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
</ItemGroup>
</Project>
# host.json - Function runtime configuration
{
"version": "2.0",
"logging": {
"applicationInsights": {
"samplingSettings": {
"isEnabled": true,
"excludedTypes": "Request"
}
}
},
"extensionBundle": {
"id": "Microsoft.Azure.Functions.ExtensionBundle",
"version": "[4.*, 5.0.0)"
},
"concurrency": {
"dynamicConcurrencyEnabled": true,
"snapshotPersistenceEnabled": true
}
}
# local.settings.json - Local development settings
{
"IsEncrypted": false,
"Values": {
"AzureWebJobsStorage": "UseDevelopmentStorage=true",
"FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
}
}The project structure follows .NET conventions with Azure Functions-specific configuration. The host.json file controls runtime behavior, while local.settings.json provides local development configuration.
Let's deploy and test this function.
# Build and deploy the function
dotnet build
dotnet publish -c Release -o ./publish
# Create function app in Azure
az functionapp create --resource-group myResourceGroup \
--consumption-plan-location eastus \
--runtime dotnet-isolated \
--functions-version 4 \
--name my-ecommerce-functions \
--storage-account myStorageAccount
# Deploy function code
az functionapp deployment source config --name my-ecommerce-functions \
--resource-group myResourceGroup \
--branch main \
--repo-url https://github.com/myorg/ecommerce-functions \
--manual-integration
# Test the function locally
func start
# Test the deployed function
curl -X POST https://my-ecommerce-functions.azurewebsites.net/api/orders \
-H "Content-Type: application/json" \
-H "x-functions-key: your-function-key" \
-d '{
"customerId": "customer123",
"items": [
{
"productId": "product1",
"quantity": 2,
"unitPrice": 29.99
}
]
}'With these commands, you've deployed a serverless function that scales automatically. Azure handles all the infrastructure while you focus on code.
Triggers and Bindings: The Power of Declarative Integration
What makes Azure Functions powerful isn't just the serverless execution-it's the rich ecosystem of triggers and bindings that connect your functions to Azure services without boilerplate code.
// Queue-triggered function for reliable message processing
[Function("ProcessOrderPayment")]
public async Task ProcessOrderPayment(
[QueueTrigger("order-payments", Connection = "AzureWebJobsStorage")] OrderPayment payment,
[Queue("payment-results", Connection = "AzureWebJobsStorage")] IAsyncCollector<PaymentResult> results,
FunctionContext context)
{
var logger = context.GetLogger("ProcessOrderPayment");
logger.LogInformation($"Processing payment for order {payment.OrderId}");
try
{
// Process payment
var result = await _paymentService.ProcessPaymentAsync(payment);
// Send result to output queue
await results.AddAsync(result);
logger.LogInformation($"Payment processed successfully for order {payment.OrderId}");
}
catch (Exception ex)
{
logger.LogError(ex, $"Payment processing failed for order {payment.OrderId}");
// Send failure result
await results.AddAsync(new PaymentResult
{
OrderId = payment.OrderId,
Success = false,
Error = ex.Message
});
}
}
// Timer-triggered function for scheduled tasks
[Function("CleanupExpiredSessions")]
public async Task CleanupExpiredSessions(
[TimerTrigger("0 */30 * * * *")] TimerInfo timer,
FunctionContext context)
{
var logger = context.GetLogger("CleanupExpiredSessions");
logger.LogInformation("Starting cleanup of expired sessions");
var expiredSessions = await _sessionService.GetExpiredSessionsAsync(
TimeSpan.FromHours(24));
foreach (var session in expiredSessions)
{
await _sessionService.DeleteAsync(session.Id);
logger.LogInformation($"Deleted expired session {session.Id}");
}
logger.LogInformation($"Cleaned up {expiredSessions.Count} expired sessions");
}
// Blob-triggered function for file processing
[Function("ProcessUploadedImage")]
public async Task ProcessUploadedImage(
[BlobTrigger("uploads/{name}", Connection = "AzureWebJobsStorage")] Stream imageStream,
string name,
[Blob("thumbnails/{name}", Connection = "AzureWebJobsStorage")] BlobClient thumbnailBlob,
FunctionContext context)
{
var logger = context.GetLogger("ProcessUploadedImage");
logger.LogInformation($"Processing uploaded image: {name}");
try
{
// Process image (resize, optimize, etc.)
using var processedImage = await _imageService.ProcessImageAsync(imageStream, name);
// Upload thumbnail
await thumbnailBlob.UploadAsync(processedImage.ThumbnailStream, overwrite: true);
// Update metadata
await _imageService.UpdateMetadataAsync(name, processedImage.Metadata);
logger.LogInformation($"Successfully processed image {name}");
}
catch (Exception ex)
{
logger.LogError(ex, $"Failed to process image {name}");
throw; // Let Azure Functions handle retry logic
}
}
// Event Grid-triggered function for event-driven processing
[Function("HandleProductEvents")]
public async Task HandleProductEvents(
[EventGridTrigger] EventGridEvent eventGridEvent,
FunctionContext context)
{
var logger = context.GetLogger("HandleProductEvents");
logger.LogInformation($"Received event: {eventGridEvent.EventType}");
switch (eventGridEvent.EventType)
{
case "ProductCreated":
var product = eventGridEvent.Data.ToObject<Product>();
await _searchService.IndexProductAsync(product);
await _cacheService.InvalidateProductCacheAsync(product.Id);
break;
case "ProductUpdated":
var updatedProduct = eventGridEvent.Data.ToObject<Product>();
await _searchService.UpdateProductIndexAsync(updatedProduct);
await _cacheService.InvalidateProductCacheAsync(updatedProduct.Id);
break;
case "ProductDeleted":
var deletedProduct = eventGridEvent.Data.ToObject<Product>();
await _searchService.RemoveFromIndexAsync(deletedProduct.Id);
await _cacheService.InvalidateProductCacheAsync(deletedProduct.Id);
break;
}
}Each trigger automatically handles the connection details, serialization, and error handling. The queue trigger ensures messages are processed reliably with built-in retry logic. The timer trigger runs on a schedule without any cron job management.
Bindings make data access declarative. Instead of writing database connection code, you declare what data you need and Azure Functions handles the rest.
// Cosmos DB input binding
[Function("GetOrderDetails")]
public async Task<HttpResponseData> GetOrderDetails(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "orders/{orderId}")] HttpRequestData req,
[CosmosDB("ecommerce", "orders", Connection = "CosmosDBConnection",
Id = "{orderId}", PartitionKey = "{orderId}")] Order order,
FunctionContext context)
{
var logger = context.GetLogger("GetOrderDetails");
if (order == null)
{
logger.LogWarning("Order {orderId} not found", req.Url.Segments.Last());
var notFoundResponse = req.CreateResponse(HttpStatusCode.NotFound);
await notFoundResponse.WriteStringAsync("Order not found");
return notFoundResponse;
}
var response = req.CreateResponse(HttpStatusCode.OK);
await response.WriteAsJsonAsync(order);
return response;
}
// Table Storage output binding
[Function("LogUserActivity")]
public async Task LogUserActivity(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
[Table("UserActivity", Connection = "AzureWebJobsStorage")] IAsyncCollector<UserActivity> activities)
{
var activity = new UserActivity
{
PartitionKey = "UserActivities",
RowKey = Guid.NewGuid().ToString(),
UserId = await req.ReadAsStringAsync(), // Simplified for example
Activity = "PageView",
Timestamp = DateTime.UtcNow
};
await activities.AddAsync(activity);
}
// Service Bus output binding
[Function("SendOrderNotification")]
public async Task SendOrderNotification(
[QueueTrigger("order-updates")] OrderUpdate update,
[ServiceBus("order-notifications", Connection = "ServiceBusConnection")] IAsyncCollector<OrderNotification> notifications)
{
var notification = new OrderNotification
{
OrderId = update.OrderId,
CustomerId = update.CustomerId,
Status = update.Status,
Message = $"Your order {update.OrderId} is now {update.Status}"
};
await notifications.AddAsync(notification);
}Bindings eliminate boilerplate code while providing automatic error handling and retry logic. The Cosmos DB binding handles connection pooling, the table storage binding manages batching, and the Service Bus binding ensures reliable message delivery.
Durable Functions: Stateful Workflows in a Stateless World
The biggest challenge with serverless functions is maintaining state across multiple executions. Durable Functions solve this by providing orchestration capabilities that maintain state automatically.
// Orchestrator function that coordinates the workflow
[Function("ProcessOrderWorkflow")]
public static async Task ProcessOrderWorkflow(
[OrchestrationTrigger] TaskOrchestrationContext context)
{
var orderRequest = context.GetInput();
try
{
// Step 1: Validate order
var validationResult = await context.CallActivityAsync(
"ValidateOrder", orderRequest);
if (!validationResult.IsValid) return new OrderResult { Success = false, Error = validationResult.Error };
// Step 2: Reserve inventory
var reservationId = await context.CallActivityAsync("ReserveInventory", orderRequest);
// Step 3: Process payment with retry
var paymentRequest = new PaymentRequest { OrderId = reservationId, Amount = orderRequest.Items.Sum(item => item.UnitPrice * item.Quantity) };
var retryOptions = new RetryOptions(firstRetryInterval: TimeSpan.FromSeconds(5), maxNumberOfAttempts: 3);
var paymentResult = await context.CallActivityWithRetryAsync("ProcessPayment", retryOptions, paymentRequest);
if (!paymentResult.Success)
{
await context.CallActivityAsync("ReleaseInventory", reservationId);
return new OrderResult { Success = false, Error = "Payment failed" };
}
// Step 4: Create shipment and send confirmation
var shipmentId = await context.CallActivityAsync("CreateShipment", new ShipmentRequest { OrderId = reservationId, Items = orderRequest.Items, CustomerId = orderRequest.CustomerId });
await context.CallActivityAsync("SendOrderConfirmation", new ConfirmationRequest { OrderId = reservationId, ShipmentId = shipmentId, CustomerId = orderRequest.CustomerId });
return new OrderResult { Success = true, OrderId = reservationId, ShipmentId = shipmentId };
}
catch (Exception ex)
{
context.SetCustomStatus($"Workflow failed: {ex.Message}");
return new OrderResult { Success = false, Error = ex.Message };
}
}
// Activity functions (stateless, idempotent)
[Function("ValidateOrder")]
public static ValidationResult ValidateOrder([ActivityTrigger] CreateOrderRequest request)
{
if (request.Items == null || !request.Items.Any()) return new ValidationResult { IsValid = false, Error = "Order must contain at least one item" };
if (request.Items.Any(item => item.Quantity <= 0 || item.UnitPrice <= 0)) return new ValidationResult { IsValid = false, Error = "All items must have positive quantity and unit price" };
return new ValidationResult { IsValid = true };
}
[Function("ReserveInventory")]
public static async Task ReserveInventory([ActivityTrigger] CreateOrderRequest request)
{
var reservationId = Guid.NewGuid().ToString();
foreach (var item in request.Items)
{
var success = await InventoryService.ReserveItemAsync(item.ProductId, item.Quantity, reservationId);
if (!success) throw new InvalidOperationException($"Insufficient inventory for product {item.ProductId}");
}
return reservationId;
}
// HTTP trigger to start the orchestration
[Function("StartOrderProcessing")]
public static async Task StartOrderProcessing(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
[DurableClient] DurableTaskClient client)
{
var orderRequest = await req.ReadFromJsonAsync();
var instanceId = await client.ScheduleNewOrchestrationInstanceAsync("ProcessOrderWorkflow", orderRequest);
return client.CreateCheckStatusResponse(req, instanceId);
} Durable Functions provide orchestration capabilities with built-in retry logic, compensation, and state management. The orchestrator function coordinates activities while maintaining state across function executions.
This pattern enables complex workflows that are reliable, scalable, and maintainable.
Dependency Injection and Configuration Management
Proper dependency injection and configuration management are crucial for maintainable Azure Functions. The isolated worker model provides full .NET Core capabilities.
// Program.cs - Configure DI and services
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
var host = new HostBuilder()
.ConfigureFunctionsWorkerDefaults()
.ConfigureServices(services =>
{
// Add application services
services.AddSingleton<IOrderService, OrderService>();
services.AddSingleton<IPaymentService, StripePaymentService>();
services.AddSingleton<IInventoryService, InventoryService>();
services.AddSingleton<INotificationService, SendGridNotificationService>();
// Add HTTP client for external API calls
services.AddHttpClient<PaymentService>(client =>
{
client.BaseAddress = new Uri("https://api.stripe.com/v1/");
client.Timeout = TimeSpan.FromSeconds(30);
});
// Add Azure clients
services.AddAzureClients(builder =>
{
builder.AddBlobServiceClient(
Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
builder.AddQueueServiceClient(
Environment.GetEnvironmentVariable("AzureWebJobsStorage"));
});
// Add custom configuration
services.Configure<OrderProcessingOptions>(
Configuration.GetSection("OrderProcessing"));
})
.Build();
host.Run();
// Service implementations
public class OrderService : IOrderService
{
private readonly ILogger<OrderService> _logger;
private readonly IPaymentService _paymentService;
private readonly IInventoryService _inventoryService;
public OrderService(
ILogger<OrderService> logger,
IPaymentService paymentService,
IInventoryService inventoryService)
{
_logger = logger;
_paymentService = paymentService;
_inventoryService = inventoryService;
}
public async Task<Order> ProcessOrderAsync(CreateOrderRequest request)
{
_logger.LogInformation("Processing order for customer {CustomerId}",
request.CustomerId);
var order = new Order
{
Id = Guid.NewGuid().ToString(),
CustomerId = request.CustomerId,
Items = request.Items,
Total = request.Items.Sum(item => item.UnitPrice * item.Quantity),
Status = OrderStatus.Processing
};
// Process payment
var paymentResult = await _paymentService.ProcessPaymentAsync(
new PaymentRequest { OrderId = order.Id, Amount = order.Total });
if (!paymentResult.Success)
{
order.Status = OrderStatus.PaymentFailed;
_logger.LogWarning("Payment failed for order {OrderId}", order.Id);
}
else
{
// Reserve inventory
var inventoryReserved = await _inventoryService.ReserveItemsAsync(
order.Id, request.Items);
if (!inventoryReserved)
{
order.Status = OrderStatus.InventoryUnavailable;
// Refund payment would go here
_logger.LogWarning("Inventory unavailable for order {OrderId}", order.Id);
}
else
{
order.Status = OrderStatus.Confirmed;
_logger.LogInformation("Order {OrderId} processed successfully", order.Id);
}
}
return order;
}
}
// Configuration options
public class OrderProcessingOptions
{
public int MaxRetries { get; set; } = 3;
public TimeSpan PaymentTimeout { get; set; } = TimeSpan.FromSeconds(30);
public decimal MaxOrderValue { get; set; } = 10000;
public bool EnableNotifications { get; set; } = true;
}This setup provides the same dependency injection capabilities as ASP.NET Core applications, enabling testable, maintainable code with proper separation of concerns.
Event-Driven Architecture: Building Reactive Systems
Event-driven architecture is where serverless truly shines. Instead of monolithic applications, you build systems composed of functions that respond to events.
// Event publisher service
public class EventPublisher
{
private readonly EventGridPublisherClient _eventGridClient;
public async Task PublishOrderEventAsync(string eventType, Order order)
{
var events = new[] { new EventGridEvent(subject: $"order/{order.Id}", eventType: eventType, dataVersion: "1.0", data: order) };
await _eventGridClient.SendEventsAsync(events);
}
}
// Domain events in business logic
public class OrderService : IOrderService
{
public async Task CreateOrderAsync(CreateOrderRequest request)
{
var order = new Order { Id = Guid.NewGuid().ToString(), CustomerId = request.CustomerId, Items = request.Items, Status = OrderStatus.Pending };
await _repository.SaveAsync(order);
await _eventPublisher.PublishOrderEventAsync("OrderCreated", order);
return order;
}
}
// Event handlers
[Function("HandleOrderCreated")]
public async Task HandleOrderCreated([EventGridTrigger] EventGridEvent eventGridEvent)
{
if (eventGridEvent.EventType != "OrderCreated") return;
var orderData = eventGridEvent.Data.ToObject();
await _searchService.IndexOrderAsync(orderData);
await _notificationService.SendOrderConfirmationAsync(orderData);
}
[Function("HandleOrderConfirmed")]
public async Task HandleOrderConfirmed([EventGridTrigger] EventGridEvent eventGridEvent)
{
if (eventGridEvent.EventType != "OrderConfirmed") return;
var orderData = eventGridEvent.Data.ToObject();
await _inventoryService.ReserveItemsAsync(orderData.OrderId, orderData.Items);
await _shippingService.ScheduleShipmentAsync(orderData);
} Event-driven architecture enables loosely coupled systems where each function focuses on a specific responsibility. Events flow through the system, triggering appropriate responses without tight coupling.
This approach provides excellent scalability, fault tolerance, and maintainability.
Testing Azure Functions: Unit Tests and Integration Tests
Testing serverless functions requires different approaches than traditional applications. You need to test functions in isolation while mocking external dependencies.
// Unit tests for function logic
public class OrderFunctionsTests
{
private readonly Mock<IOrderService> _orderServiceMock;
private readonly Mock<ILogger<OrderFunctions>> _loggerMock;
private readonly OrderFunctions _functions;
public OrderFunctionsTests()
{
_orderServiceMock = new Mock<IOrderService>();
_loggerMock = new Mock<ILogger<OrderFunctions>>();
_functions = new OrderFunctions(_orderServiceMock.Object, _loggerMock.Object);
}
[Fact]
public async Task CreateOrder_ValidRequest_ReturnsCreatedOrder()
{
// Arrange
var request = new CreateOrderRequest
{
CustomerId = "customer123",
Items = new List<OrderItem>
{
new OrderItem { ProductId = "product1", Quantity = 2, UnitPrice = 29.99m }
}
};
var expectedOrder = new Order
{
Id = "order123",
CustomerId = request.CustomerId,
Items = request.Items,
Total = 59.98m,
Status = OrderStatus.Pending
};
_orderServiceMock
.Setup(x => x.CreateOrderAsync(request))
.ReturnsAsync(expectedOrder);
// Act
var result = await _functions.CreateOrder(request);
// Assert
Assert.NotNull(result);
Assert.Equal("order123", result.Id);
Assert.Equal(OrderStatus.Pending, result.Status);
Assert.Equal(59.98m, result.Total);
_orderServiceMock.Verify(x => x.CreateOrderAsync(request), Times.Once);
}
[Fact]
public async Task CreateOrder_InvalidRequest_ThrowsArgumentException()
{
// Arrange
var request = new CreateOrderRequest
{
CustomerId = "",
Items = new List<OrderItem>()
};
// Act & Assert
await Assert.ThrowsAsync<ArgumentException>(() =>
_functions.CreateOrder(request));
}
}
// Integration tests with Azure Functions Test Host
public class FunctionsIntegrationTests : IClassFixture<FunctionsTestFixture>
{
private readonly HttpClient _client;
public FunctionsIntegrationTests(FunctionsTestFixture fixture)
{
_client = fixture.Client;
}
[Fact]
public async Task CreateOrder_HTTPTrigger_ReturnsOrderId()
{
// Arrange
var request = new CreateOrderRequest
{
CustomerId = "customer123",
Items = new List<OrderItem>
{
new OrderItem { ProductId = "product1", Quantity = 1, UnitPrice = 29.99m }
}
};
// Act
var response = await _client.PostAsJsonAsync("/api/orders", request);
// Assert
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadFromJsonAsync<OrderResponse>();
Assert.NotNull(result.OrderId);
Assert.True(Guid.TryParse(result.OrderId, out _));
}
[Fact]
public async Task GetOrder_OrderExists_ReturnsOrderDetails()
{
// Arrange
var orderId = "existing-order-id";
// Act
var response = await _client.GetAsync($"/api/orders/{orderId}");
// Assert
response.EnsureSuccessStatusCode();
var order = await response.Content.ReadFromJsonAsync<Order>();
Assert.NotNull(order);
Assert.Equal(orderId, order.Id);
}
}
public class FunctionsTestFixture : IDisposable
{
private readonly FunctionsApplication _application;
public HttpClient Client { get; }
public FunctionsTestFixture()
{
_application = new FunctionsApplication();
Client = _application.CreateClient();
}
public void Dispose()
{
Client.Dispose();
_application.Dispose();
}
}
// Test host setup
public class FunctionsApplication : IDisposable
{
private readonly WebApplicationFactory<Program> _factory;
public FunctionsApplication()
{
_factory = new WebApplicationFactory<Program>()
.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
// Replace real services with test doubles
services.Replace(ServiceDescriptor.Singleton<IOrderService, FakeOrderService>());
});
});
}
public HttpClient CreateClient() => _factory.CreateClient();
public void Dispose() => _factory.Dispose();
}Unit tests focus on function logic with mocked dependencies, while integration tests verify end-to-end behavior using the Azure Functions Test Host.
Monitoring, Observability, and Performance Optimization
Serverless applications require comprehensive monitoring since you can't access the underlying infrastructure directly. Application Insights provides deep observability.
// Custom telemetry and structured logging
[Function("ProcessOrderWithTelemetry")]
public async Task ProcessOrderWithTelemetry(
[QueueTrigger("orders")] Order order,
FunctionContext context)
{
var logger = context.GetLogger("ProcessOrderWithTelemetry");
// Start operation for distributed tracing
using var operation = logger.StartOperation(
"ProcessOrder", order.Id, new Dictionary<string, object>
{
["OrderId"] = order.Id,
["CustomerId"] = order.CustomerId,
["OrderTotal"] = order.Total
});
try
{
// Custom metrics
var metrics = new Dictionary<string, double>
{
["OrderProcessing.Start"] = 1,
["OrderTotal"] = (double)order.Total
};
logger.LogMetric("OrderProcessing", metrics);
// Process order with timing
var stopwatch = Stopwatch.StartNew();
await _orderService.ProcessAsync(order);
stopwatch.Stop();
// Log performance metrics
logger.LogMetric("OrderProcessing.Duration", stopwatch.ElapsedMilliseconds);
logger.LogMetric("OrderProcessing.Success", 1);
operation.Complete();
}
catch (Exception ex)
{
// Log failure with context
logger.LogError(ex, "Order processing failed for order {OrderId}", order.Id);
logger.LogMetric("OrderProcessing.Failure", 1);
operation.Fail(ex);
throw;
}
}
// Custom middleware for consistent observability
public class ObservabilityMiddleware : IFunctionsWorkerMiddleware
{
public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
{
var logger = context.GetLogger("ObservabilityMiddleware");
var startTime = DateTime.UtcNow;
var correlationId = GetOrCreateCorrelationId(context);
using var scope = logger.BeginScope("{CorrelationId}", correlationId);
logger.LogInformation("Function {FunctionName} started", context.FunctionDefinition.Name);
try
{
await next(context);
var duration = DateTime.UtcNow - startTime;
logger.LogInformation("Function {FunctionName} completed in {Duration}ms", context.FunctionDefinition.Name, duration.TotalMilliseconds);
logger.LogMetric("Function.Success", 1);
}
catch (Exception ex)
{
var duration = DateTime.UtcNow - startTime;
logger.LogError(ex, "Function {FunctionName} failed", context.FunctionDefinition.Name);
logger.LogMetric("Function.Failure", 1);
throw;
}
}
private static string GetOrCreateCorrelationId(FunctionContext context)
{
if (context.BindingContext.BindingData.TryGetValue("Headers", out var headersObj) &&
headersObj is HttpHeaders headers &&
headers.TryGetValues("x-correlation-id", out var correlationValues))
return correlationValues.First();
return Guid.NewGuid().ToString();
}
}Comprehensive observability enables you to monitor performance, debug issues, and optimize costs in serverless environments.
Cost Optimization and Performance Best Practices
Serverless pricing can surprise you if you're not careful. Understanding the cost model and optimization techniques is crucial for production deployments.
// Cost-optimized function with efficient execution
[Function("ProcessOrdersBatch")]
public async Task ProcessOrdersBatch(
[TimerTrigger("0 */5 * * * *")] TimerInfo timer,
[CosmosDB("ecommerce", "pending-orders",
SqlQuery = "SELECT * FROM c WHERE c.status = 'pending'",
Connection = "CosmosDBConnection")] IEnumerable<Order> pendingOrders,
[CosmosDB("ecommerce", Connection = "CosmosDBConnection")] IAsyncCollector<Order> ordersOut,
FunctionContext context)
{
var logger = context.GetLogger("ProcessOrdersBatch");
var ordersToProcess = pendingOrders.Take(50).ToList(); // Process in batches
if (!ordersToProcess.Any())
{
logger.LogInformation("No pending orders to process");
return;
}
logger.LogInformation("Processing {Count} orders in batch", ordersToProcess.Count);
// Process orders in parallel with controlled concurrency
var semaphore = new SemaphoreSlim(10); // Limit concurrent operations
var tasks = ordersToProcess.Select(async order =>
{
await semaphore.WaitAsync();
try
{
order.Status = OrderStatus.Processing;
order.ProcessedAt = DateTime.UtcNow;
// Process order (simplified)
await Task.Delay(100); // Simulate processing time
order.Status = OrderStatus.Completed;
await ordersOut.AddAsync(order);
}
catch (Exception ex)
{
logger.LogError(ex, "Failed to process order {OrderId}", order.Id);
order.Status = OrderStatus.Failed;
await ordersOut.AddAsync(order);
}
finally
{
semaphore.Release();
}
});
await Task.WhenAll(tasks);
logger.LogInformation("Completed processing batch of {Count} orders", ordersToProcess.Count);
}
// Memory-optimized function with appropriate sizing
[Function("GenerateReport")]
public async Task<HttpResponseData> GenerateReport(
[HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req,
FunctionContext context)
{
var logger = context.GetLogger("GenerateReport");
// Use streaming for large data to minimize memory usage
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/json");
await using var writer = new StreamWriter(response.Body);
await writer.WriteAsync("{\"status\":\"starting\"}");
// Process data in chunks
var totalRecords = 0;
await foreach (var chunk in _reportService.GetDataChunksAsync())
{
totalRecords += chunk.Count;
await writer.WriteAsync($",\"chunk_{totalRecords}\":{JsonSerializer.Serialize(chunk)}");
// Yield control periodically to prevent timeouts
await Task.Yield();
}
await writer.WriteAsync($",\"totalRecords\":{totalRecords},\"status\":\"completed\"}}}");
await writer.FlushAsync();
return response;
}Cost optimization involves choosing the right memory allocation, processing data efficiently, and using appropriate execution patterns.
Security Considerations for Serverless Applications
Serverless security requires a different mindset. You can't control the underlying infrastructure, so security focuses on application-level controls and Azure platform features.
// Secure function with proper authentication and authorization
[Function("GetUserProfile")]
public async Task<HttpResponseData> GetUserProfile(
[HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req,
FunctionContext context)
{
var logger = context.GetLogger("GetUserProfile");
// Extract user claims from JWT token
var claimsPrincipal = await _authenticationService.AuthenticateAsync(req);
if (claimsPrincipal == null)
{
var unauthorizedResponse = req.CreateResponse(HttpStatusCode.Unauthorized);
await unauthorizedResponse.WriteStringAsync("Authentication required");
return unauthorizedResponse;
}
var userId = claimsPrincipal.FindFirst("sub")?.Value;
if (string.IsNullOrEmpty(userId))
{
var badRequestResponse = req.CreateResponse(HttpStatusCode.BadRequest);
await badRequestResponse.WriteStringAsync("Invalid user token");
return badRequestResponse;
}
// Check authorization
if (!await _authorizationService.CanAccessProfileAsync(claimsPrincipal, userId))
{
var forbiddenResponse = req.CreateResponse(HttpStatusCode.Forbidden);
await forbiddenResponse.WriteStringAsync("Access denied");
return forbiddenResponse;
}
// Get and return user profile
var profile = await _userService.GetProfileAsync(userId);
if (profile == null)
{
var notFoundResponse = req.CreateResponse(HttpStatusCode.NotFound);
await notFoundResponse.WriteStringAsync("Profile not found");
return notFoundResponse;
}
var response = req.CreateResponse(HttpStatusCode.OK);
await response.WriteAsJsonAsync(profile);
return response;
}
// Function with input validation and sanitization
[Function("UpdateProduct")]
public async Task<HttpResponseData> UpdateProduct(
[HttpTrigger(AuthorizationLevel.Function, "put", Route = "products/{productId}")] HttpRequestData req,
string productId,
FunctionContext context)
{
var logger = context.GetLogger("UpdateProduct");
try
{
// Validate productId format
if (!Guid.TryParse(productId, out _))
{
var badRequestResponse = req.CreateResponse(HttpStatusCode.BadRequest);
await badRequestResponse.WriteStringAsync("Invalid product ID format");
return badRequestResponse;
}
var requestBody = await req.ReadAsStringAsync();
var updateRequest = JsonSerializer.Deserialize<ProductUpdateRequest>(requestBody);
// Validate input
var validationResult = await _validator.ValidateAsync(updateRequest);
if (!validationResult.IsValid)
{
var badRequestResponse = req.CreateResponse(HttpStatusCode.BadRequest);
await badRequestResponse.WriteAsJsonAsync(validationResult.Errors);
return badRequestResponse;
}
// Sanitize input
updateRequest.Name = _sanitizer.SanitizeHtml(updateRequest.Name);
updateRequest.Description = _sanitizer.SanitizeHtml(updateRequest.Description);
// Update product with optimistic concurrency
var result = await _productService.UpdateProductAsync(productId, updateRequest);
if (!result.Success)
{
var conflictResponse = req.CreateResponse(HttpStatusCode.Conflict);
await conflictResponse.WriteStringAsync("Product was modified by another request");
return conflictResponse;
}
var response = req.CreateResponse(HttpStatusCode.OK);
await response.WriteAsJsonAsync(result.Product);
return response;
}
catch (Exception ex)
{
logger.LogError(ex, "Error updating product {ProductId}", productId);
var errorResponse = req.CreateResponse(HttpStatusCode.InternalServerError);
await errorResponse.WriteStringAsync("An error occurred processing your request");
return errorResponse;
}
}Security in serverless requires defense in depth: authentication, authorization, input validation, and proper error handling.
Summary
Azure Functions and serverless computing represent a fundamental shift in how we build cloud-native applications. By embracing event-driven patterns and leveraging Azure's serverless capabilities, you can create systems that scale automatically while focusing on business logic rather than infrastructure management.
The journey from traditional applications to serverless involves rethinking architecture, embracing events, and adopting new operational practices. The isolated worker model provides full .NET capabilities with dependency injection, while triggers and bindings eliminate boilerplate integration code. Durable Functions solve the state management challenge, enabling complex workflows with built-in reliability. What makes serverless powerful for C# developers is the familiar ecosystem combined with cloud-native capabilities, allowing teams to move faster, scale further, and focus on delivering business value.
Serverless computing isn't just a technology choice-it's a mindset that enables innovation at cloud scale. By mastering Azure Functions, you're not just learning a new technology; you're adopting a new way of building software that scales with your imagination.