Navigating ASP.NET Core Routing Metadata

Uncovering the use of Metadata in ASP.NET Core endpoint routing is like getting a superpower. The moment you understand how metadata is applied and how it drives features like Authorization, Rate-Limiting, CORS and OpenAPI you will get a better understanding how it works and fits together.

I will be your guide in this code safari into the realms of ASP.NET Core endpoint routing and it's use of metadata. You will learn how metadata is added in multiple ways, how it integrates with middleware, and how it can serve as a foundation for building custom middleware.

Unlocking the potential of OpenAPI with .NET 10

In this session, learn how OpenAPI can transform how you describe, version, and distribute your .NET backend APIs. We'll dive into how to implement Web APIs in .NET 10 using a code-first approach while seamlessly generating OpenAPI definitions. Discover how to streamline your workflow, manage API versions effectively, and provide your consumers with robust clients and documentation, all powered by OpenAPI.

How to build a Minesweeper grandmaster

Minesweeper isn't a hard game to solve, until you want to know all the possibilities of each square.
I will show you how to build a multiplayer Minesweeper game where you play against each other or a ruthless computer player.

To calculate the best possible move, the computer player needs to solve Minesweeper and calculate all possibilities. On an empty board of 16x16 with 51 mines, there are exactly 2E+54 possibilities. To crack this problem, I used a lot of optimizations to do this within 100ms.

In this talk, you'll learn about fancy data structures, benchmarking, memory profiling, and how to get the most performance out of complex algorithms in .NET.

Opinionated things you must add to your .NET 10 cloud application

This session is all about tips, tricks and essentials I think you should know when building cloud-native applications with .NET. As a very opinionated developer I will share the tools which I use, add or copy to every solution.
I will try to fit as much content as possible and will try to at least cover the following topics:
- .NET & MSBuild tricks
- Versioning
- Openapi
- Containers
- Minimal Api's

Fine-grained real-time web apps with Blazor & Orleans

Real-time features can enhance your Blazor app, but they often come with unnecessary complexity. What if there was a way to only subscribe to updates when they are truly needed, avoiding wasted resources and simplifying your app’s architecture? By combining Blazor with Orleans, you can create durable, observable objects (Grains) that allow components to subscribe to updates only when they are rendered. This approach gives you precise, fine-grained control over the real-time behavior of your app.

In this practical session, you will learn how to integrate Orleans into your Blazor project to build modern, real-time solutions. We will cover how the powerful Virtual Actor model of Orleans makes it simple to handle state changes almost instantly while maintaining scalability and performance. By the end, you will see why Blazor and Orleans are a perfect match for creating interactive, scalable applications without overcomplicating your codebase. Whether you are building dashboards, collaborative tools, games, or live data feeds.

First given on NDC Oslo 2024: https://www.youtube.com/watch?v=Y3aopzc0vnI&list=PLbn7orn-xom6Dtr4BNo6UgGDGkhn-sCWm

Forever /api/v1.0 with ASP.NET Core

API Versioning is hard. But not because adding and maintaining a new version involves a lot of work. It's actually deprecation of older versions which causes everything to break.

In this session we will cover possible breaking changes, some hidden surprises and how to keep evolving your API and stay on v1.0 as long as possible. If none of the provided strategies work, I will give you the tools to introduce new versions with the least amount of impact and how to not surprise your API consumers and clients.