Speakers: Gregor Dostal

You don’t always need a custom Dockerfile to run integration tests in a containerized environment. In the .NET ecosystem, Aspire and Testcontainers offer two distinct approaches to leveraging Docker for testing. Whether you need full-stack orchestration or lightweight, test-scoped infrastructure, understanding their strengths will help you choose the right tool for the job.

Speakers: Shahab Ganji

As a .NET dev who thinks in events (hi, Shahab The Guy ), I’ll show how to turn app behavior into evidence you can graph, search, and trust. In 10 minutes we’ll wire up OpenTelemetry once, add Serilog for structured logs, and ship traces, metrics, and logs straight to Grafana Cloud—while also lighting up the .NET Aspire dashboard for local dev.

Speakers: Stefan Pölz

Would you like to know how incremental source generation and source-level interception grant you Native AOT & performance “for free”?

The just-in-time compiler (JIT) is a mighty beast of the .NET runtime. And it becomes more powerful with every consecutive release of .NET. But it comes along with a cost during run-time, when compiling the assemblies containing intermediate language code into machine code. A price we may not pay gladly for highly scalable cloud services. Native AOT, compiling deployments ahead-of-time into executable code, moves this complexity to compile-time. But features that utilize dynamic code emission may stop working.

As a solution serve Interceptors which were shipped as experimental C#-only feature in .NET 8 and became GA in .NET 9. An interceptor is basically the inverse of a goto statement that enables the Roslyn compiler to replace reflection-based call sites with specialized implementations. Emitted from (incremental) source generators, codebases become more trimmable, more Native AOT-friendly and can unlock better performance.

May Roslyn be with you!

Speakers: Christoph Wille

Use EF migrations and you are all set, they said. Not so fast! Are your changes compatible with already existing data? Are your changes backward compatible?

What about DDL vs DML permissions? And then the elephant in the room: is EF migrations actually the best choice, or is a model-based approach even better?

Let’s find out what the “It depends” reasons are.

Speakers: Raoul Holzer, David Eiwen

In this talk, we will explore the DataSync CommunityToolkit, a powerful tool designed to simplify the integration of data in modern offline clients. We will discuss how it can be used to synchronize data between local and remote sources, ensuring that your applications remain responsive and up-to-date even when offline. The DataSync CommunityToolkit provides a set of APIs and utilities that make it easy to manage data synchronization, conflict resolution, and offline storage. We will demonstrate how to use these features in a practical example, showcasing the benefits of using the toolkit in your applications.

Speakers: Shahab Ganji

The most prominent shift we’ve observed in the field of distributed systems over the last decade is probably the transition from traditional synchronous integrated systems to message-driven means. This change is a logical response to the high demands for scalability, elasticity, and resilience within today’s software systems.
Regardless of how overwhelming the array of message-based options may seem, Azure Cosmos DB serves as an incredible solid backbone for most of them, whether utilized as a transactional outbox or a fully-fledged event store in the context of event-sourcing.
By diving deeper into real-world experiences, we will discover the mechanics of how Cosmos DB can guarantee nearly infinite scalability if you follow a few basic principles and patterns to efficiently model your data.
While Cosmos DB should not be considered as another silver bullet, this talk will teach you why you should certainly keep it as a prominent tool in your toolkit when it comes to building event-driven systems at scale.

Speakers: Andreas Willich, Markus Enzlberger

Debugging and optimizing applications can often feel like navigating in the dark. Traditional log files are disorganized, verbose, and challenging to interpret, leaving teams overwhelmed and searching for a signal in a sea of noise. This issue isn’t limited to complex, distributed systems—it happens even in ordinary applications, where logs fail to provide clarity. Compounding the problem is the uncertainty about the time and effort needed to achieve specific performance levels. Without clear insights into bottlenecks, it’s difficult to know where to focus or whether your efforts will yield meaningful results.

But what if you could replace the chaos with clarity? What if troubleshooting felt like uncovering the full picture—precise, contextual, and actionable? And what if you could predict and measure the impact of your performance optimizations, removing the guesswork? Observability makes this possible by transforming the way we monitor and debug systems.

In this talk, Andreas Willich from TechTalk and Markus Enzlberger from XXXLutz will demonstrate how observability can tackle both challenges head-on. Using a real-world application built with MongoDB and Apache Kafka, they’ll show how rich traces, real-time metrics, and actionable visualizations enable faster root cause analysis, more efficient optimizations, and a clearer path to achieving your performance goals. Join us to uncover how observability empowers you to understand, improve, and take control of your systems.

Speakers: Rainer Stropek

Software development is undergoing a revolution: For many developers, AI assistance systems have become indispensable. They take on routine tasks, generate simple algorithms, create tests, document code, and much more. GitHub Copilot is considered a pioneer and market leader in this field – but strong alternatives are challenging the top player and driving innovation forward. In this session, Rainer Stropek provides an overview of the latest developments in GitHub Copilot and introduces exciting challengers like Cursor and Windsurf. There will also be time for an open discussion about the opportunities and risks of AI in software development.

Speakers: Martin Ullrich

.NET Aspire is an opinionated, cloud-ready stack for building observable, production-ready, distributed applications.
For some months it is GA but the development continues and continues.
Martin gives us an overview of the best features of Aspire. And perhaps he shows us some hidden ones too!

Speakers: Jiří Činčura

Visual Studio offers a plethora of nobs, switches and tools to make life easier when debugging. In fact there might be even too much. I’ll show you my tool-belt with tools I use regularly and I’ll make take your debugging skills to next level.

Speakers: Raoul Holzer, David Eiwen

Getting fat again with WinUI 3 and the Windows App SDK but reactive by David Eiwen & Raoul Holzer

Join us for an enlightening session where our expert speakers, David and Raoul, share their journey of migrating an old Universal Windows Platform (UWP) app to the modern Windows UI Library (WinUI) 3.0 using the Windows App SDK. Through real-world examples and practical insights, they’ll discuss the challenges faced during the migration process and the innovative solutions they implemented.
In addition, they will present how Rx.NET can be integrated well with a WinUI 3 app.

Speakers: Bas Dijkstra

Setting up and running integration and end-to-end tests in distributed software systems is hard. Making sure that all components are deployed, with the right version, in the right state, with the right data is a challenging task for many teams.

Contract-based testing is an approach that tries to address this problem and simplify and speed up integration testing for distributed software systems.

In this talk and live demo, you’ll learn about the basic principles behind contract-based testing, the questions it tries to answer, and the three different approaches to contract-based testing. You will also see contract-based testing in action, using the well-known Pact.Net library for C#. To wrap up the talk, we will also talk about how to adopt contract-based testing in your team and organization, and some of the potential pitfalls that should be addressed along the way.

Speakers: Alex Gavrilescu

We will demonstrate how it is possible to allow 2 players from different parts of the world to play against each other with the minimum latency possible and have the game validation done on the backend side.

The Unity client will use a user interface driven by reactive data models which will be updated using a SignalR connection to the server.

Speakers: Andreas Willich

GitHub Copilot has been available in Visual Studio for over nearly 2 years now and we see more and more AI features popping up in Visual Studio and Visual Studio Code.
All of these features are behind an additional subscription that your company or you have to pay.
So the big question is, do you get a useful tool for this extra money? And if so, how do you convince your boss to pay for it?

Andreas tried to find an answer to this question in the last year by daily driving GitHub Copilot for various tasks at his work as a Developer.

Speakers: Paul Rohorzka, David Walsner

With the latest changes to the language, C# moves into the direction of a multi-paradigm language, enabling to write code in an object oriented and also increasingly functional style. Besides the support of the language itself, railway oriented programming is a concept from the functional world that can also be leveraged in C#. In this talk David and Paul dive into the concept of railway oriented programming and what it means to use this approach in big applications. They share some experience and discuss their love-hate relationship with this approach.