.NET Days
Online 2024

ReSharper turned 20! Some people have been using it from the very beginning, some for just a year or two. In this talk, we’ll discuss how ReSharper has evolved over the years and what it has become.

In this session, we’ll explore Blazing Story, a template inspired by Storybook that allows developers to develop Blazor components in isolation. We’ll discuss the use of Playwright for end-to-end testing and explore the integration of an accessibility testing library to ensure that the components comply with the agreed guidelines.

ASP.NET was a bit behind the curve when it came to the MVC pattern. It was not until 2009 that Microsoft released the first version of ASP.NET MVC. This was a time when the MVC pattern was already well-established in the web development community. Part of the reason for this was that Microsoft was initially heavily invested in WebForms. Later, they pivoted to Silverlight as the future of web development. Aside from legacy projects, WebForms is now a thing of the past. Silverlight is also long gone.

Today, there's a lot of talk about the new and shiny Blazor. But I'm not convinced that it will fully replace ASP.NET MVC. And I'm not convinced that it should. This talk will be a homage to the good old (new) ASP.NET Core MVC. In it, I’ll explain why I think it's still a good choice for web development in 2024.

When coding standards, architectural guidelines, and conventions are only available in non-executable forms like documentation and diagrams, code quality tends to deteriorate over time. This deterioration leads to increased complexity, lower quality, and the accumulation of technical debt. To counteract this decline in quality, it’s essential to actively validate your source code against design rules and architectural standards as part of your DevOps pipeline.

This talk will explore several techniques for enforcing coding standards in .NET development. We’ll see how to use Reflection and Roslyn for thorough code analysis and demonstrate the implementation of architecture unit tests. We’ll also highlight the use of Roslyn analyzers and tools like NDepend and Qodana to provide real-time feedback. Additionally, we’ll introduce Metalama, a powerful tool that offers a fresh perspective on architecture enforcement, combining simplicity with real-time validation.

Dive into the dynamic world of web development in this engaging talk, where we explore the innovative blend of HTMX with ASP.NET Core Razor Pages. Discover how to bring simplicity back to your web applications without sacrificing power or scalability. We'll navigate through practical examples demonstrating how HTMX can make your Razor Pages more interactive with minimal JavaScript. Learn to enhance user experiences with easy-to-implement features like long polling, modals, and server-side validation that feel like the client side without a full page refresh. Whether you're a seasoned developer or new to the ASP.NET ecosystem, this talk will equip you with the knowledge to create more responsive and efficient web applications. Get ready to transform your approach to web development by leveraging the best of both worlds: the robustness of ASP.NET Core and the simplicity of HTMX.

Integration tests are crucial to ensuring your app's reliability. However, traditional options for writing these with EF Core, such as using SQLite or a real dev database, often introduce challenges both in terms of maintainability and confidence – sometimes even secretly making tests pass with false positives.

This session will offer an alternative, a library called Testcontainers, that addresses these challenges. After going through the more common options and their pitfalls, I'll introduce the Testcontainers library, the benefits it offers, and demonstrate with a coding demo how to implement it in some real integration tests using EF Core.

While this talk will be made with .NET in mind and use examples in C#, the Testcontainers library is offered in 10+ languages, and the knowledge can be transferred to other ecosystems. Attendees will be assumed to have basic knowledge of unit and integration testing.

We tend to call some F# language features "lifesavers", but what if I told you we actually built software for saving lives? In this talk, I'll walk you through designing custom DSLs for applications used by emergency operations center controllers with a pinch of C# and F# interop on the top of a SignalR- and Fable Compiler-powered UI renderer.

After the introduction of the await operator, C# developers can write asynchronous code in a way that looks almost like regular synchronous code. There's no more need for explicit callbacks and lambda expressions in certain scenarios. Great! However, it did not add a solution for multi-threaded programming. With the help of IAsyncDisposable, IAsyncEnumerable, and some custom task-like types, we can make multi-threading as easy as async/await. Come learn how to make async/await even more powerful and unlock the way to write multithreaded code cleanly and concisely.

ReSharper has a ton of great features for code analysis, quick fixes, testing and much more. It's easy to forget that ReSharper is also great for editing text. Let's have a quick look at some of its advanced editing features - and let's stop using the mouse to select/copy/paste. It's time to work semantically!

NUKE brings your build automation to an even level with every other .NET project. How? It’s a regular console application allowing all the OOP goodness! Besides, it solves many common problems in build automation, like parameter injection, path separator abstraction, access to solution and project models, and build step sharing across repositories. NUKE can also generate CI/CD configurations (YAML, etc.) that automatically parallelize build steps on multiple agents to optimize throughput!

This deep dive will reveal the magic behind how Rider seamlessly integrates with Blazor WebAssembly to provide a dynamic, real-time development experience. We'll explore the technical architecture, delve into the communication mechanisms between the IDE, the runtime, and the browser, and understand how code changes are instantly reflected without a full reload. Perfect for developers looking to enhance their knowledge of Blazor capabilities, this session will provide a thorough understanding of the behind-the-scenes processes that make hot reload a powerful tool in your Blazor Wasm development toolkit.

One of the goals of building microservice-based architectures is to reduce the complexity of individual components. In doing so, much of that complexity shifts from individual services towards interservice communication, making how we design those service interactions essential to our system design. That's where orchestration and choreography come in – two coordination techniques that can help us design complex workflows in our system.

In this session, we’ll thoroughly examine each pattern with practical examples from the banking sector that are based on almost five years of experience in this domain. By thoroughly understanding the trade-offs of each approach and understanding the right questions to ask, we can build a mental framework that helps us make well-balanced decisions about which pattern to use. Join me in this session, where we’ll transform the abstract concepts of orchestration and choreography into a tangible decision-making framework that steers you in the right direction!

In a forever-evolving world of microservices, with so many moving parts, we often rely on integration testing to prevent bugs and regressions.

The problem with these tests is that sometimes they become flaky, unreliable, and expensive to maintain and execute, due to the distributed nature of our system.

But what if we could ensure that our system’s components are compatible and can communicate with each other straight from the development phase?

Let’s have a look at what contract testing is and see how it can help us mitigate the risk of integration bugs before running long tests, with examples in C#.

The .NET Aspire stack bundles together an opinionated collection of libraries and tooling designed to streamline the development of distributed applications for developers. At the heart of .NET Aspire is its built-in orchestrator, which offers a code-centric approach, allowing you to effortlessly manage all the resources that make up your application – containers, executables, projects, and configurations – with the power of strong typing.

In this session, we’ll explore how you can use the API in the application model to compose the resources that make up our distributed application. We’ll get a solid understanding of what Aspire Resources are, explore some of the built-in resource types, as well as learn how we can create our own custom resources.