Advanced Distributed Systems with .NET 11 and Aspire

In this hands-on workshop, Dylan Beattie will walk you through some of the most enduring patterns and protocols in distributed systems design. We’ll work with HTTP APIs, gRPC, channels, streams and message queues. We’ll implement patterns like outboxes and circuit breakers that we can use to improve resilience and performance. We’ll use Aspire and OpenTelemetry to visualise and troubleshoot what’s actually happening inside our applications - and, this being the age of AI-assisted coding tools, we’ll look at how (and when) AI tools can help you develop and support these kinds of systems.

Introduction

• What are “distributed systems”?
• Monoliths and microservices
• The fallacies of distributed computing revisited
• Principles of distributed architecture

Observability and Aspire

• Introducing Aspire
• Using OpenTelemetry with .NET
• Principles of observability: spans, traces, metrics and logs
• “Works on my machine” : localhost vs production considerations

HTTP, REST and Hypermedia

• Designing HTTP APIs
• Understanding REST
• Working with HTTP APIs: testing and tooling
• Interactive documentation with OpenAPI and Scalar

Message queues and pub/sub

• Principles of message queues
• In-process queues using .NET channels
• Distributed queues with RabbitMQ and EasyNetQ
• Queueing strategies and error handling

Protocol Buffers and gRPC

• Introduction to Protocol Buffers
• Contract-first development using protocol definitions
• Cross-platform gRPC

Connecting to the Web

• Integrating browsers with distributed systems
• Protocols for realtime communication
• Realtime notifications with websockets and SignalR

Advanced Messaging Patterns

• Transactional outboxes
• Exactly-once delivery (and why it’s impossible)
• Working with sagas: choreography vs orchestration
• Circuit breakers

What About AI?
This is not an AI coding workshop. The focus is on understanding patterns and principles of distributed architecture, and you’ll be be able to apply those patterns in your own projects regardless of whether you’re using AI tools or not.

That said, we’ll be using tools like Claude Code and OpenSpec to implement components and parts of our example applications, we’ll be reviewing AI-generated code to see how it works, and we’ll be talking about how the same protocol definitions and API specifications that we rely on when we’re integrating decoupled services can be used to direct and constrain AI tools as part of an agent-based development workflow. If you’re already using Claude or Copilot on your projects, you’ll find plenty here to keep them busy; if you’ve not used AI tools at all, this is a great opportunity to see what they can do and how we’re using them.

Target Audience and Prerequisites
This workshop is aimed at developers with some experience writing applications using C# and Microsoft .NET. Attendees will be writing and running .NET code during the workshop, so will need a computer running Windows, macOS or Linux, and the Microsoft .NET 11 SDK from https://dotnet.microsoft.com/download. The sample application and examples used during the workshop all run on .NET 11, and are tested on Linux, macOS and Windows.