Packaging your world with NuGet

Whether you are creating an open source library or building enterprise app core components, you need to get that functionality into other projects. But developing these resources is usually easier than consuming them. How about a worry free way to distribute and reference those resources in your project that will let you stay up to date, but allow you to avoid problems that may introduce breaking changes or new bugs? NuGet packages to the rescue! We'll also take a look at where you can find NuGet (packages aren't just for code any more) and how to create, distribute, and maintain your very own package. Then, you’ll be ready to share your package with your team, your enterprise, or even… The world!

Learning Objectives

The learner will:
* understand the many ways to create a NuGet package, both with VS and NuGet command line
* understand versioning concerns, especially around a public package
* understand things they can do to make their public packages self-documenting and ease new dev adoption

Putting the Fun in Func with Lambdas & LINQ

Working with delegates in C# is easier than ever with .NET's generic Action and Func types. Understanding .NET delegates is key to harnessing the power of language features like Lambdas and LINQ. In this session, we'll dig into delegates, exploring what they are, how they work, and how they can help you be a SOLID developer. Don't let delegates put you in a Func, take Action, and learn how to make your code simpler, cleaner, and more flexible.

Learning Objectives

The learner will:
* understand Delegates, in their many forms, and how to use Lambdas
* be able to take advantage of Action and Func when utilizing delegates in their code
* be able to use Delegates and Lambdas to unlock the potential of LINQ

How to Mock objects and influence unit tests

Want to write cleaner, more maintainable unit tests in .NET? In this session, we’ll explore powerful tools and techniques to simplify test setup, reduce boilerplate code, and make assertions more intuitive. You'll learn how to effortlessly mock dependencies, isolate your tests from external APIs and databases, and improve overall test reliability. We’ll cover strategies to automatically inject mocked dependencies into your test subjects, ensuring your tests are both efficient and resilient. Whether you're new to unit testing or looking to refine your approach, this session will give you practical insights to take your testing game to the next level.

Covers .NET unit testing with AutoFixture, NSubstitue, and Shouldly and bring general tips for better test development

Coding Paradise: The Future of App Creation with .NET MAUI

Dive into cross-platform app development with .NET MAUI, Microsoft's Multi-platform App UI framework. Learn how MAUI allows you to craft native mobile and desktop applications using C# and XAML. You'll be able to unify your development efforts for Android, iOS, macOS, and Windows under a single shared codebase while still enabling access to every aspect of each native platform. Unlock the potential of .NET MAUI, where the creation of cross-platform applications becomes an accessible reality.

Testing the Waters: Navigating Unit Testing in the Blazor Universe

Let's take a look at unit testing Blazor UIs. Learn how to render components, inspect output, and trigger event handlers, all crucial for testing the UI in your Blazor applications. We'll step through the intricacies of mocking external dependencies, ensuring that your tests are not only efficient but also stable. These skills are indispensable for developers striving to build resilient solutions in Blazor. Discover how to seamlessly integrate testing into your development workflow, gaining the confidence to deliver stable and reliable Blazor applications.

Blazing Trails: Your Guide to Effortless Web Development with Blazor

Let's explore Blazor, a revolutionary .NET frontend web framework that seamlessly blends server-side rendering and client interactivity. With Blazor, you can craft interactive UIs using C# while sharing logic across server and client. Benefit from the familiarity of .NET, leverage a vast ecosystem of libraries, and enjoy the performance, reliability, and security inherent in the framework. We'll delve into the fundamental concept of Blazor components, C# classes that define UI rendering logic, handle user events, and offer a reusable and shareable approach to building web applications. Discover the simplicity and robustness of using C# on the client-side, bid farewell to traditional JavaScript-centric approaches, and learn to encapsulate functionality into reusable components for cleaner, more maintainable code. Whether you're a seasoned developer or a newcomer eager to explore, this session will help you unlock the true potential of Blazor, reshaping your web development journey for greater productivity and enjoyment.

Beyond the Build: Crafting Maintainable Projects with MSBuild

Tired of repetitive project setup and configuration headaches? MSBuild is more than just a build tool—it’s your key to efficient, maintainable, and scalable project management. In this session, we’ll explore how to harness MSBuild to centralize settings, automate processes, and streamline builds across enterprise solutions. Whether you're just getting started or looking to level up your skills, you'll walk away with practical strategies to optimize your workflow, reduce redundancy, and take control of your projects. Say goodbye to build chaos and hello to a smarter, more efficient development experience!

Building Connected Apps with .NET MAUI

We’ve all seen the standard .NET MAUI demo where a colorful button increments a counter or a static list scrolls perfectly on a high-speed connection. It’s a clean, perfect world where everything works on the first try. But the second you take that app into the wild, reality hits. Real users don’t have predictable data, and they certainly don’t want their sensitive information handled as an afterthought. The gap between a “File > New Project” demo and a production-ready app is a mountain of architectural work that most tutorials quietly skip.

This session goes beyond the vacuum of the demo app. We’ll dive into the architectural foundations that make real-world MAUI apps successful—how to structure your codebase so it stays maintainable, manage services and dependencies so your app remains testable, and design for unreliable connectivity with an offline-first mindset. We’ll also tackle practical concerns like secure storage and authentication, moving beyond hardcoded strings to patterns that can actually be trusted. By the end of the session, you won’t just have seen another hello world demo—you’ll have a practical grasp of how to build .NET MAUI apps that are resilient, secure, and ready for real people using real devices.

This session's goal is to help developers understand how to build real-world MAUI apps that interact with APIs, handle identity, survive unreliable networks, and remain maintainable—without overwhelming them with infrastructure details.

Beyond HttpClient: Consuming APIs in .NET

We’ve all written that one-liner HttpClient call that “just works” in a quick console app or small feature. It’s the fastest way to get data moving, but that simplicity is deceptive. As applications grow, those quick calls often turn into duplicated logic, hardcoded strings, and brittle integrations that are difficult to test and painful to maintain. In modern applications, APIs are a critical dependency—and how you consume them matters just as much as how they’re built.

In this session, we’ll move beyond the “quick and dirty” approach and treat API consumption as a first-class architectural concern. We’ll look at common pitfalls like improper connection lifetimes, messy error handling, and subtle production issues such as socket exhaustion and DNS blind spots. You’ll learn how using HttpClientFactory and typed abstractions help bring structure, testability, and reliability to your integrations. By the end, you'll have a battle-tested strategy for building API integrations that don't just work on your machine, but actually survive the chaos of production.

Learning Objectives
• Understand why naïve HttpClient usage causes problems in production
• Identify common failure modes when consuming APIs in .NET
• Learn patterns for building testable, maintainable, and resilient API integrations
• Treat API consumption as a first-class architectural concern

Failure Is a Feature: Designing for the Unhappy Path

Most applications are designed around the happy path; where we have valid input, fast network responses, and dependencies that behave exactly as expected. We tend to treat failure as an annoying edge case, something to be buried in a try/catch block or ignored because it "shouldn’t ever happen." But in a modern .NET environment, those assumptions are dangerous. Between flaky APIs, transient network timeouts, and users who will inevitably click the "Submit" button ten times in a row, failure isn't an accident; it’s a guarantee.

This session is about learning to treat the unhappy path as a core part of your application’s design. We’ll dig into the common points of failure that plague .NET apps and why they shouldn't all be handled the same way. We’ll look at the trade-offs between using exceptions and functional return types, and how design choices around retries and timeouts can either make your system resilient or just hide a much bigger problem. Our goal is to develop a practical strategy for building systems that fail predictably and recover gracefully, so the next production outage becomes a managed event rather than a total surprise.

Learning Objectives:
* Recognize why designing only for the happy path is dangerous in modern .NET applications
* Identify different categories of failure and understand why they require different handling strategies
* Evaluate when exceptions are appropriate versus when functional return types are a better design choice
* Design retry and timeout strategies that improve resilience rather than masking deeper issues
* Adopt a failure-aware mindset that leads to predictable, manageable production behavior