Steve Gordon

Information & Communications Technology

ASP.NET Core .NET C#.Net

Eastbourne, England, United Kingdom

Steve Gordon

Senior Engineer at Elastic, Microsoft MVP and Pluralsight author

Steve Gordon is a Pluralsight author, Microsoft MVP, senior engineer based in the UK. He works for Elastic maintaining their .NET client libraries. Steve is passionate about community and all things .NET related, having worked with ASP.NET for over 16 years. Steve enjoys sharing his knowledge through his blog, in videos and by presenting talks at user groups and conferences. Steve is excited to be a part of the .NET community and founded .NET South East, a .NET Meetup group based in Brighton. He enjoys contributing to and maintaining OSS projects. You can find Steve online at his blog and on Twitter as @stevejgordon.

Current sessions

Writing Code with Code: Getting Started with the Roslyn APIs

As developers, we spend ours days writing code. What if we could get the computer to write it for us? Using the .NET Roslyn APIs, we can do exactly 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.

Steve will also touch on another use of the Roslyn APIs with the C#9 feature "Source Generators". By writing and distributing source generators, we can add code at compile-time to augment codebases and avoid repetition.

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

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

In this session, you'll learn how to write C# code which executes faster and allocates less. This session is packed with practical examples and demos of where the latest high-performance APIs and language features can be applied in your applications.

During this session, we'll apply types such as Span and Memory to efficiently process data and to parse strings. We'll examine System.IO.Pipelines, offering high-performance I/O and we'll utilise ArrayPool to help reduce GC allocations. In .NET Core 3.0, we have new high-performance JSON APIs which we'll also add to our arsenal. Microsoft has made fantastic performance gains to the .NET Core framework; now it's time to apply them to your code!

We'll begin by discussing when and why performance matters in your applications. You'll learn how to measure your code, and use a data-driven approach to focus your optimisations.

These features can 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 used by thousands of companies 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 and the NEST client library.

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.