Writing Code with Code: Getting Started with the Roslyn APIs

As developers, we spend our days writing code. What if we could get the computer to write it for us? Using the .NET Roslyn APIs, we can do precisely that!

In this session, Steve will share his latest work at Elastic, generating the majority of the .NET client for Elasticsearch from a simple specification. Steve will introduce and demonstrate how to get started with leveraging the Roslyn APIs. He will show you how the Elastic .NET code generator transforms a JSON spec into a C# syntax tree and outputs thousands of classes in only a few seconds.

You'll leave this session with an understanding of the Roslyn APIs and how to utilise them in your work. You'll understand core concepts such as syntax trees, the SyntaxFactory and tools to help you write code with code.

Practical OpenTelemetry Instrumentation for .NET Applications

Are your .NET applications truly observable? Do you want to learn how to instrument your .NET applications using OpenTelemetry? If so, join Steve to learn from a real-world example.

In this session, Steve will introduce OpenTelemetry and the APIs we should use in .NET to instrument applications for distributed tracing.

Most applications today focus on emitting logs. For richer observability, we need to go further. Distributed tracing provides greater context about how our applications function and provides insight across application boundaries, which is critical in modern microservice and cloud architectures.

This session focuses on the practicalities of instrumenting code and the decisions teams must make along the way. We'll focus on a worked example of instrumenting a library while discussing the choices and best practices to consider. We'll dive into the implementation details of the actual code and discuss our design choices.

Beyond the code, we'll discuss formalising an approach to observability for tracing across teams and how to ensure consistent standards are applied.

Whether you are new to OpenTelemetry or already familiar with the fundamental concepts, this session will guide you in the practical application of instrumentation techniques for your C# codebase.

Preferred length: 60 minutes

How to not HATE public speaking!

Does the prospect of speaking in public send you into cold sweats? It's not uncommon to struggle with speaking in public. In this talk, you'll learn to face your fears and develop the skill of presenting.

Steve will explore his fear of public speaking and share his story of facing that fear and becoming an international conference speaker in under one year, almost accidentally! You'll learn how and why Steve left his comfort zone and dealt with his nerves.

Software developers learn from one another almost constantly in our rapidly growing and evolving industry. In the software community, sharing knowledge is both rewarding and extremely valuable. Steve will talk about the fantastic benefits that becoming a technical speaker can offer to individuals and their careers.

During the talk, Steve will share tips and techniques to help new speakers prepare to present a topic to an audience. He'll explain his process to develop, rehearse and deliver complex technical talks. Being well prepared can significantly reduce the anxiety and fear leading up to delivering a talk. And you'll learn what to expect as a technical speaker at conferences.

Join Steve in this comprehensive session to learn how he turned his hate of public speaking into a passion for presenting and career growth. Hopefully, you'll leave this session inspired to start your speaking journey.

Preferred duration: 60 mins

Background Services in ASP.NET Core and .NET

Do you need to perform long-running workloads and build .NET microservices? In this session, based on his five-star Pluralsight course, Steve will teach you when and how to apply hosted services in your applications.

You will learn about the .NET hosting extensions library, the foundation of ASP.NET Core and .NET worker service projects. Steve will discuss the hosting lifecycle and crucial implementation details.

In this code-heavy session, Steve will demonstrate adding hosted services to ASP.NET Core to perform background work outside the request lifecycle. He will also demonstrate building modern microservices using .NET with the worker service template. Along the way, he will share fascinating details of how things are implemented and how to control the fine details to tune your code.

By the end of this session, you will have a strong knowledge of building ASP.NET Core hosted services and using the .NET worker service template, which will help you as you build responsive web applications and .NET microservices.

Preferred duration: 60 mins

What can we learn from the world's shortest C# program?

In this advanced session, Steve creates and explores the shortest C# program, unpacking the implementation details that make .NET work. There's a lot we can learn from two characters of code!

This code and tool-heavy session begins by creating the smallest possible C# application. After building it, we dig into the output to understand how the C# compiler transforms our code into a working executable. We profile the application allocations to understand implementation details and explore how the cross-platform DLL is hosted on platforms to boot up the .NET runtime.

You'll learn some fascinating details about how .NET works under the covers.

Unveiling .NET Secrets with the World's Smallest C# Program

Sometimes, the most profound lessons come from the simplest examples. Have you ever wondered how the .NET runtime works?

Prepare for a unique journey into the intricacies of .NET. We'll dissect the world's smallest C# program, unlocking deep insights into the compilation and execution of .NET applications.

Equipped with powerful tools, including PerfView, DotMemory, DotPeek, and WinDbg, we'll explore the .NET runtime environment and its inner workings like never before, uncovering fundamental principles that support the .NET applications we develop.

Whether you're new to .NET, aiming to build a strong foundation, or a seasoned developer eager to deepen your appreciation for the framework's core mechanics, this session promises to transform your perspective on C# and .NET programming.

We will delve into advanced topics, providing a rare glimpse into how .NET works. These insights will open an intriguing window into the framework you use daily, enriching your understanding, sparking your curiosity, and empowering you to tackle more complex tasks.

Join Steve for an engaging and insightful journey through the essence of. NET. This demo-heavy session promises to transform your perspective on C # and .NET programming, proving that even the smallest programs can teach us invaluable lessons and impact our approach to software development.

This talk is designed to fit 60-minute conference sessions.

Let's Talk HTTP in .NET Core

In the world of microservices (yes, there's that buzzword again!) and distributed systems, we often find ourselves communicating over HTTP. What seems like a simple requirement can quickly become complicated! Networks aren't reliable and services fail. Dealing with those inevitable facts and avoiding a cascading failure can be quite a challenge. In this talk, Steve will explore how we can build .NET Core applications that make HTTP requests and rely on downstream services, whilst remaining resilient and fault tolerant.

This session will focus on some of the improvements which have been released in .NET Core and ASP.NET Core 2.1, such as IHttpClientFactory and the new, more performant socket-based handler. Steve will identify some HTTP anti-patterns and common mistakes and demonstrate how we can refactor existing code to use the new HttpClientFactory features.

Next, Steve will demonstrate Polly; a fantastic resilience and transient fault handling library which can be used to make your applications less prone to failure. When integrated with the Microsoft HttpClientFactory; wrapping your HTTP calls in retries, timeouts and circuit-breakers has never been easier!

If you're building services which make HTTP calls, then this talk is for you!

An intermediate level session aimed at .NET developers. Can be adjusted in length from 45min to 1hr 30mins.

Anatomy of ASP.NET Core Requests

Have you ever wondered how a browser/client request actually results in a response from ASP.NET Core? Have you ever been constrained by the default behaviour of ASP.NET Core and wanted to change how it works? If so, then this talk is for you.

In this session, Steve will explore the lifecycle of incoming requests in ASP.NET Core, touring through the layers from Kestrel, to hosting, to middleware and then on into MVC itself. You'll see how the pieces all fit together and learn about the places where you can inject your own implementations to customise, augment and override the ASP.NET Core defaults.

Steve will show the hidden extension points that can take you to power-user levels when building your ASP.NET Core applications, such as applying custom conventions, filters and model binding behaviour. You'll leave this talk with ideas for improving your ASP.NET Core applications and reducing code by refactoring cross-cutting concerns.

Don't fight the framework, customise it!

In this session, I provide an in-depth look at how ASP.NET Core processes HTTP requests. I'll describe the flow through the application host, the Kestrel web server, middleware and finally through MVC. The intent is to use this narrative to explain some advanced features of ASP.NET Core which support customising its behaviour.

Key take-aways:
- How application hosting works
- How Kestrel receives requests from the network Socket and parses them
- How the middleware pipeline can be used to respond to requests
- How endpoint routing works
- How filters can be used to intercept and modify requests within MVC
- How MVC finally handles a request.

This session is aimed at ASP.NET Core developers of intermediate/advanced experience.

Turbocharged: Writing High-Performance C# and .NET Code

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.

We'll begin by focusing on when and why performance matters in applications. You'll learn how to profile and benchmark your code using a data-driven approach to focus your optimisations.

At first, these concepts may seem complicated, unapproachable and difficult to apply. In this session, Steve introduces high-performance newcomers to the features, showing you how they work, where they can be applied and how to measure performance improvements in your code.

This talk is for developers who, like Steve, are ready to begin their journey towards writing faster .NET code, which allocates less.

This talk is aimed at all levels of .NET Core developers. It's intended to provide real-world experience of applying high-performance techniques to .NET code. It shares the journey and experience of a relative performance novice, learning about these features for the first time to solve real problems and optimise code. The audience will leave this talk with the knowledge to begin leveraging performance features and inspired to try them in their code.

An Introduction to Elasticsearch for .NET Developers

Elasticsearch is a leading search and analytics solution thousands of companies use worldwide for use cases, including search, analytics, monitoring and security information and event management. With an emphasis on speed, scale, and relevance, it's transforming how the world uses data.

In this session, we'll learn about leveraging the power of Elasticsearch within .NET applications, utilising the Elasticsearch.NET client library. Join Steve to learn about the .NET client, how to install it in .NET applications and use it to begin indexing and searching documents.

This session is aimed at software developers looking to get started by combining the capabilities of Elasticsearch with their .NET applications. You'll leave with the core knowledge required to begin using Elasticsearch with .NET.

String Manipulation in C#: Deep Dive

Strings are one of the most common types in any application you will build. All developers should therefore take time to understand the string type. There may be more them than you first realise! In this session, together with Steve, you will explore how Strings work and how to manipulate them efficiently.

Steve will focus on the pros and cons of string immutability and help you to understand why manipulating strings can be costly for application performance. Steve will demonstrate techniques we can use to avoid heavy performance penalties and optimise string manipulation code.

Steve will go below the surface, explaining how strings, along with types like StringBuilder work internally. You will leave this session appreciating the power and complexity of using strings in your own .NET applications.