JetBrains .NET Day Online ’23

How to recreate a classic ’90s game using .NET and F# using the same techniques (an actual rasterized ray caster – it's all pixels!) to run natively in both the desktop and the browser.

OpenTelemetry has quickly become the go-to industry standard for distributed tracing, logging, and metrics. Its widespread adoption across the industry, including the .NET ecosystem, has made it a breeze to use in your applications. However, larger, more complex systems introduce challenges that require us to strengthen our understanding of observability, align on our observability goals, and better understand the full capabilities of the OpenTelemetry project.
We need to understand how to choose the right observability signal for each use case, apply a set of best practices to the telemetry we collect, manage costs through different sampling strategies, and select the optimal architecture by leveraging the OpenTelemetry Collector. In this session, you'll learn the right questions to ask and gain a deeper understanding of the available options in the observability space to become more effective in spying on your systems!

Collecting logs, traces, and metrics in .NET applications has become a breeze recently. With support for automatic instrumentation and an increasing number of libraries starting to generate telemetry signals, it's easier than ever to build observable software.
Manually instrumenting your existing software can be a pain, though. Instead of spending valuable time on this, what if we let the Roslyn compiler do it for us?
Join Denis in a fun coding session, where we will automate the process of instrumenting our codebase using Roslyn source generators. We will implement a well-known structural design pattern using incremental source generators and a sprinkle of OpenTelemetry.

Entity Framework Core is great for performing crud operations, but did you know you can also go beyond basic relational queries? For example, do you need to store and query unstructured data in JSON documents? Do you have hierarchical data that you wish to query with EF Core? Are you required to keep historical information about data that has been modified or maybe even deleted? If you answered "Yes" to any of the above questions, this is the talk you do not want to miss.
In this session, you will see how to achieve the above goals with EF Core. Specifically, I will step through and show how you can use EF Core for JSON documents, how to use temporal tables to keep the complete history of your data and query hierarchical data with EF Core 8.
Developers working with EF Core will learn to store data in JSON columns and how easily they can drill into the JSON data with familiar LINQ query syntax. You will see how to filter and sort results based on elements of the JSON document, project elements from JSON, and even update the JSON document. Furthermore, you will see how temporal tables can store all the historical data and how straightforward it is to query for historical records with EF Core. Finally, I will show how to query hierarchical data with the upcoming version of EF Core 8. Join me for a demo-rich session and learn about EF Core features that you will be able to apply right after the session.

Microservice Architecture has been thoroughly discussed, as have the reasons why you should move to it (and why you shouldn’t). If you have already decided to move over to microservices from monolithic development, then you may find the whole process a bit daunting. What aspects should you, as a developer, be concerned with? What does all the terminology mean? How do the services talk to each other?
In this session, I’ll show you how to get started with microservice architecture, answering these and many other questions. We'll look at The Tacky Tacos project, built with ASP.NET 6, and explore how the whole process fits together from a development point of view.
Hopefully, you'll leave the session with the confidence to start your own microservices application development straight away!

Join Mike as he delves into the exciting world of cross-platform .NET development, powered by Avalonia UI and JetBrains Rider! This session will demonstrate how Avalonia UI enables you to create sleek, modern applications that run seamlessly across Windows, macOS, Linux, iOS, Android, and WebAssembly. After discussing Avalonia UI, Mike will showcase how to revitalize legacy WPF applications and bring them to life on macOS and Linux using Avalonia XPF and JetBrains Rider!
Whether you're an experienced .NET developer or just starting your journey, this session is your ticket to embracing the future of cross-platform development.

Debug infrastructure implementation for .NET (Blazor) WebAssembly apps is challenging due to its unique execution environment. In this talk, we will dive deep into the hidden difficulties of debugger IDE frontend implementation for .NET WASM apps.
We'll start with an overview of the Blazor WASM app execution anatomy, reviewing Debug Proxy. We will then compare regular .NET debugging with Blazor debugging and introduce Rider Debugging Infrastructure. Next, we'll discuss the steps involved in debug session initialization, including how the CDP (Chrome DevTools Protocol) is used. We will also cover breakpoints and evaluation. Finally, we will have a brief discussion about hot-reload, how it works, and how it is supported from the IDE side.
This talk is essential for .NET developers working with Blazor WASM and anyone interested in understanding the complexities of debugging .NET WASM applications.

In this talk, you will see how features added to recent versions of C# can dramatically improve parsing and generation of JSON data compared with longer-established .NET JSON handling mechanisms. You will see how to use high-performance memory-efficient techniques, and also how code generators can reduce runtime overheads. This talk will explore the tradeoff between maximizing performance and ease of use and will show you how to choose between the various options now available in modern .NET applications.

Learn what it takes to write the fastest Dictionary for .NET. Faster than the .NET Dictionary, faster than FrozenDictionary. You will learn how to use BenchmarkDotNet, dotTrace, and vTune to tune the most performance critical pieces of code and write optimized data structures in .NET. Whether you write C#, VB.NET, or F# you will learn how to extract the maximum performance from .NET.

xUnit is one of the most-used testing tools for C#, yet its full capability often goes underutilized. Unfortunately, there isn't much guidance or documentation for developers in terms of what libraries to use with xUnit or some of the more uncommon functionality of xUnit itself, keeping much of its use limited to the realm of learned experience. This talk will cover some xUnit tips and tricks that come from just that: learned experience. You'll learn how to make tests easier to write and more robust, as well as other helpful libraries that can be used in tandem with xUnit to unlock its full potential.