.NET Days
Online 2025

Kick off .NET Days with a tour of what’s new and what to expect. We’ll show ReSharper working with the current Visual Studio Insiders build and share our plan for day-one readiness when the release ships, highlight recent performance gains, and demo how Rider’s AI-assisted flow supports everyday .NET work. We’ll also share housekeeping, where to find resources, and how to join the conversation.

Distributed systems can be overwhelming - but with .NET Aspire, building them feels refreshingly simple. In this session, we’ll explore a multi-service, message-driven application and see how Aspire streamlines orchestration, configuration, and diagnostics across your system.

Along the way, I’ll show how easily you can plug in messaging, persistence, and observability without the usual wiring and complexity. Once it's running locally, we’ll set up CI/CD and deploy the whole thing to the cloud - with minimal effort.

Whether you're modernizing an existing solution or starting from scratch, you’ll walk away with practical ideas and a new appreciation for Aspire’s end-to-end developer experience.

ASP.NET Core provides better support for clean, testable, maintainable architectures than any of its predecessors. Learn the underlying principles that apply to project/solution organization, how best to arrange your projects to support clean code, and how to refactor existing solutions toward this architecture. Examples will use ASP.NET Core but the principles covered apply to all languages and platforms.

Get ready to bid farewell to the dreaded System.NullReferenceException and step into the wonderful world of C# nullability!

In this session, we'll unravel the hidden magic behind nullability syntax and annotations, unleashing the power of static analysis. But hold on, it's not as simple as a sprinkle of ? and ! here and there. We'll delve into the depths and discover that it's no silver bullet either. Yep, you'll still need to keep an eye on those non-nullable variables!

Come along on a journey through the essentials of C# nullability, and let's explore techniques and approaches for integrating it into your existing code bases.

Asynchronous messaging is becoming increasingly popular in the architecture of distributed systems. And why not, when you have the benefits of increased scalability, fault-tolerance, performance, and decoupling? From ordering your latest gadget to dealing with mission-critical, high-performance systems—messaging is gaining traction.

A message queue is the most critical infrastructure in distributed systems that use messaging. There are plenty of choices, ranging from databases to cloud solutions. But how do you decide what is the best fit for your organization and your system?

Join me as I discuss some of the most popular queuing systems—AWS SQS, RabbitMQ, and Azure Service Bus —along with their benefits, trade-offs, and gotchas, accompanied by code samples. By the end of this session, attendees will have a clear understanding of each system's strengths and weaknesses and will be equipped with the knowledge to make informed decisions on the best messaging solution for their specific application architecture.

Developing cross-platform applications is complex. Some frameworks allow us to share the business logic and some go further and allow us to share the UI layer. But even then – working with device hardware requires developers familiar with each target platform to maintain it and can still lead to error-prone platform-specific code.

Uno Platform allows you to develop .NET apps from any dev environment, deploy to any platform, and use your choice of XAML or C# for the UI. You can create applications for Windows, macOS, iOS, Android, Linux, and WebAssembly using a single codebase. The framework is built on top of .NET and provides a set of tools and libraries that make it easy to build high-performance applications.

In this session, we will provide a brief overview of what Uno Platform is and how it works before we take a deep dive under the hood and see where the magic happens.

Most people say you can’t do Test Driven Development (TDD) on the frontend. They’re wrong. In this session, we will first level set on what TDD is and how to do it. Then we’ll immediately start applying TDD to Blazor using bUnit and the latest additions to bUnit I helped contribute to make TDD a breeze. We will even talk about if you can (and should) write tests for your CSS. All along the way, we will do live coding demos so that you can see TDD in action. While the demos will be using Blazor, the concepts apply to any frontend framework even in other languages.

Building an event-driven system is anything but trivial. However, once you make it past the sea of pub-sub vs. command-response debates and the service boundaries conundrum, you'll soon face the inevitable: change. The conversations that follow sound all too familiar... "Who's subscribed to this message?" "Do other services depend on this field in the payload?" "Why on earth is that thing in the payload?" "That service should never rely on this data!" And, of course, the obvious "Can't we -just- remove this?"

But are those the right questions to ask? As software developers, we aim to be agents of change, not chaos. To achieve this, we need to understand the impact of tweaking a message contract without breaking half of the system or forcing other teams beyond their deadlines. We should prioritize techniques that ensure compatibility while also considering how long that compatibility needs to be sustained. Oh, and let’s not forget that we’re supposed to solve this problem with zero downtime, as our users are spread across every time zone. In this session, we’ll discuss practical techniques and tooling that can enable the evolution of your event-driven system so that, next time a stakeholder approaches with a change request, your heart doesn't sink to the floor.

Generative AI is transforming the way we build modern applications—and with tools like Semantic Kernel and .NET Aspire, creating intelligent, cloud-native apps is now easier and more accessible than ever before.

In this session, we’ll walk through how to architect and build real-world GenAI applications using the power of the .NET ecosystem. You’ll see how .NET Aspire streamlines cloud-native development with features like automatic service discovery, built-in observability, and simplified deployment—while Semantic Kernel enables rich AI capabilities by integrating large language models (LLMs) into your application logic.

In this session, We’ll explore a hands-on, real-world GenAI app that brings together key AI capabilities like:

- Semantic Search

- Retrieval-Augmented Generation (RAG)

- Model Context Protocol (MCP)

- Vector embeddings with vector database integration

- Reasoning and planning

- Support for multiple LLM and providers

We’ll show how these capabilities come together in a scalable, modular architecture—powered by Aspire’s service orchestration and observability layer. You’ll learn how to manage and monitor your GenAI services in both development and production environments using Aspire’s built-in dashboard and integration with OpenTelemetry.

Whether you're new to Semantic Kernel or already experimenting with GenAI in .NET, this session will give you practical guidance, live code, and production-ready techniques for building intelligent applications that scale confidently across environments.

Have you been curious about functional programming, especially with the rise of these concepts in your favourite programming languages? Are you a bit scared of all those strange concepts that you'll have to learn? Good news, I too was overwhelmed by functional programming, but I've found that it's not as scary as it seems. Come find out if F# is worth your time and if functional programming is as fabulous as it seems.

Debugging memory leaks is more of an art than a science, but nevertheless it's an important facet of debugging complex applications.

We're the maintainers of Akka.NET - we maintain 100+ libraries that do various things are used by tens of thousands of active users running large-scale applications. Earlier this year, one of our users discovered a horrifying memory leak in one of our persistence plugins and was able to diagnose it using dotMemory.

We leveraged his hard work and, also using dotMemory and Rider, were able to track down the source and fix the bug. In this video we will re-use that bug and demonstrate how we regularly use dotMemory and Rider to solve performance and stability issues like memory leaks on the regular in Akka.NET.

C#'s Task-based async/await is a quite pervasive asynchronous programming model. Its beauty is encapsulated in syntactic succinctness to utilize hardware resources efficiently while maintaining sequential readability of the code.

The comprising language keywords, compiler features and framework types unlock immense semantic power:

- asynchronous operations and continuations

- error handling

- cooperative cancellation

- progress reporting

- asynchronous disposal

- asynchronous streams

and much more.

The apparent simplicity - in some cases - may conceal the root cause of performance bottlenecks or unexpected behavior. But by gaining a foundational understanding of the Async State Machine, which is the core driver of the control flow in asynchronous logic, developers can unveil potential issues with ease. An in-depth expertise of these implementation details enables authors to design reusable libraries and publish responsive applications.

In this code-heavy session, we will demystify the most prevalent aspects of C#'s async and await, as well as related .NET types.

Observability is crucial for every app even before it is deployed, and logging is the cornerstone of it. Despite its significance and the fact that so many apps run in the cloud, building an easy-to-read, distributed logging solution can pose some challenges, especially if you don’t want to pay a fortune to achieve it.

The scope of this talk is to present a step-by-step guide to how we can build an easily transferable, scalable logging system in AWS using open-source tools, without the cost of ready-made solutions that are offered in the cloud. This includes:

1. Deploying an OpenTelemetry collector instance, a Loki instance, and an instance of Grafana to AWS using ECS and Fargate,

2. Setting up EFS to be used with Loki to persist our logs,

3. Configuring a .Net API to use our newly-deployed logging system and then view these logs in Grafana,

4. Examining the cost and usability of our solution compared to AWS Cloudwatch with/without Opensearch

5. Short mention of the steps required to include tracing and metrics for a full observability suite

Many developers use Gen AI a lot for creating code. Generating unit tests is quite popular. But there is also a thing called test-driven development. And the major benefit of adopting this approach is not 100% code coverage, but rather a clean design. But can these approaches be applied together? During this session, we will dive into applying the combination for writing a piece of software. So at the end of this talk, you can make an informed decision whether TDD is useless if you use GenAI. Do not expect a lot of slides. We will spend most of our time in Rider and AI Assistant.