Introduction to Distributed Systems with .NET Core

A hands-on workshop with Dylan Beattie, covering HTTP, REST, GraphQL, gRPC, RabbitMQ, and SignalR: what they do, why you would use them, and how they all work with C# and .NET Core.

Once upon a time, software was simple. You built a website, connected it to a database, and you were done. Then customers started asking for APIs, mobile apps, notification emails, realtime chat. Cloud hosting enabled “elastic” systems - websites that automatically scale up to handle demand; message queues and publish/subscribe patterns to handle spikes in traffic and workload without impacting your end users.

If you’re just starting out with distributed systems design, the possibilities can be overwhelming. APIs, message queueing, REST, GraphQL, gRPC… what should you choose, how does it work, how do you get started?

This workshop gives you a hands-on introduction to the most important messaging patterns used in modern application development. Using .NET Core and C#, we’ll build a series of small example apps and services, wire them together using these patterns, and discuss how - and when - you’d apply the same patterns in your own applications.

Course Structure and Contents

Introduction

  • What are “distributed systems”?
  • Monoliths and microservices
  • Common integration patterns
  • Principles of distributed architecture

Connecting Components using HTTP

  • HTTP architectural patterns - XMLRPC, REST, GraphQL
  • Designing HTTP APIs
  • HTTP frameworks: WebAPI, NancyFX, ServiceStack
  • Working with HTTP APIs: testing and tooling
  • Scaling HTTP APIs: caching strategies
  • Exercise: building an HTTP API client and server

Message queues and pub/sub

  • Principles of message queues
  • Message queueing in .NET - Redis, MSMQ, EasyNetQ
  • Queueing strategies and error handling
  • Advanced architectural patterns: CQRS, event sourcing
  • Exercise: building a pub/sub system using .NET

Protocol Buffers and gRPC

  • History of RPC on .NET - SOAP, DISCO, WSDL, WCF
  • Introduction to Protocol Buffers
  • Contract-first development
  • Advantages of gRPC
  • Exercise: high-performance architecture using gRPC

Connecting to the Web

  • Integrating browsers with distributed systems
  • The “Backends for Frontends” pattern
  • Working with SignalR
  • Exercise: real-time browser notifications using SignalR

Target Audience and Prerequisites

This workshop is aimed at developers with some experience writing applications using C# and Microsoft .NET.

The workshop is run fully online, using Zoom and various online collaboration tools. Attendees will be writing and running .NET code during the workshop, so will need to join the workshop on a computer running Windows, macOS or Linux, and ideally install the Microsoft .NET SDK from https://dotnet.microsoft.com/download.

Exercises can be done in .NET Framework 4.6+ or .NET Core 2.0+

The ideal class size for this workshop is between 6–20 people. If you’d like to run it for a smaller or a larger group, please get in touch and let’s chat.

About the Trainer

Dylan Beattie is a software developer, musician and international keynote speaker. With over 20 years' experience working in the software industry, Dylan has spoken and taught at over 100 software development conferences all over the world. He's the founder and director of Ursatile, established in 2020 to provide high-quality workshop training for software professionals. He was CTO at Skills Matter in London from 2017 to 2019, and throughout 2020 he's been working with NDC Conferences to virtualise their events in the wake of the coronavirus pandemic.

Dylan is a Microsoft MVP for Developer Technologies, and the creator of the Rockstar programming language. You can find him online at dylanbeattie.net or on Twitter as @dylanbeattie

Upcoming Course Dates

No public dates are currently scheduled.

If you'd like to run this workshop for your team or at your conference, please get in touch

Alternatively, join the mailing list to find out when new course dates are announced.