Modern software relies heavily on third-party components like open-source libraries and NuGet packages, which can introduce security risks.

If you’re not carefully managing these dependencies, you could expose your application to vulnerabilities or even malicious code, just like what happened with Log4J.

In this session, we’ll cover best practices for securing your .NET projects, including using tools like Trivy and NuGet’s security features to scan and monitor dependencies. We’ll also discuss supply chain observability, how to track vulnerabilities and ensure the integrity of your components.

I’m sure most people have used an SVG at some point. Some may even have peeked inside the file, only to scream from the overwhelming jumble of numbers and letters.

But SVGs aren’t as complicated as they might first appear. Underneath all those seemingly mysterious numbers and tags is a simple description of shapes, paths, colors, and other graphical elements. Once you understand a few of the basic building blocks, creating and tweaking an SVG becomes much less intimidating.

Logging is a vital part of every application that runs in production. It is in place to tell a story about the lifecycle of its runtime and make it easy for developers to debug a system and identify what failed and how when things go wrong. It is, however, extremely easy to get it wrong, and the problems caused can stay hidden for years. In this session, I will talk you through all the possible issues that logging can cause and show you how you can fix every single one of them.

I’ve been a Microsoft field engineer for fourteen years—learn from my experience and mistakes. Today’s landscape of architectural choices for enterprise solutions is vast, with real problems to solve and real issues that come with those solutions.

Big enterprises or small, problems are problems. There are plenty of tools and frameworks, but what really sets enterprise solutions apart from one-off applications are the fundamental patterns. In this session, we’ll break down a typical enterprise architecture piece by piece, focusing on the decisions engineers and architects make when tackling common problems and requirements. We’ll dive into areas like scalability, security, integration, and maintainability, giving you practical insights whether you’re new to the field or just need a refresher.

Every tool possesses untapped potential, waiting to be discovered. Explore the poetic synchronization between EF Core and SQL Server, as they join forces to create the most elegant solutions. Let’s embark on a journey from understanding basic scaffolding to the intricacies of schema evolution and SQL debugging. It’s time to be inspired by the art of database craftsmanship.

Along the way, we’ll uncover what happens beneath the surface and learn how to move beyond simply letting the tools generate the code for us. By understanding how EF Core translates our intentions into SQL, and how SQL Server executes those instructions, we can make better decisions, diagnose problems with confidence, and get the most out of both technologies.

When JK worked with many different clients and projects, he frequently heard “EF Core is slow” or “We should do this in raw SQL” only to realize they haven’t used EF Core correctly.

JK will show you how to improve your EF Core statements as well as how various configurations impacts the performance and scalability of your application. You’ll be blown away at how small changes can significantly impact not only the performance but also stability of the application.

Caching is fundamental in building fast and reliable systems, and in .NET there are multiple ways to do that.

In this talk we’ll explore the ins and outs of caching in .NET, from memory to distributed up to hybrid caching: we’ll see both the new HybridCache from Microsoft and FusionCache.

We’ll explore common scenarios, recurring problems and how to solve them with a focus on pragmatic solutions that can be used right away in the real world.

Do you want to learn how to write C# code that executes faster and allocates less? This session is packed with practical examples and code demos of where and how high-performance APIs and language features can be applied to your applications.

This session will teach you about using types such as Span to process data and parse strings efficiently. We’ll examine System.IO.Pipelines, offering high-performance I/O, and utilise ArrayPool to help reduce GC allocations. We’ll also discuss how the low-level System.Text.Json APIs can dramatically improve JSON parsing.

Did you know that the .NET compiler turns our async methods into a struct? And that .NET adds a try/catch block to each of these classes, potentially hiding thrown exceptions? It’s true!

In this session, we will learn how to best use async/await in C# by analyzing how .NET compiles our async code.

Join me as we take an existing app and optimize its async code together, showing off performance gains, better exception handling, improved run-time speed, and smaller app size!