Ian Griffiths - Technical Fellow I

Rx.NET v7 and Futures On .NET Live talk and demos

Ian Griffiths27/02/2026

In a recent On .NET Live stream, Ian Griffiths talked about recent developments in Rx.NET and plans for v7 and future versions. This post explains where to find the demo code for that session.

T4 templates on modern .NET

Ian Griffiths18/02/2026

T4 is a .NET-based templating language. It used to target just .NET Framework. It is now possible to use modern .NET runtimes, but it requires additional work. This post shows how to get it working.

How .NET 10.0 boosted AIS.NET performance by 7%

Ian Griffiths09/12/2025

.NET 10.0 has shipped, and for the fifth year running, we benchmarked endjin's AIS.NET library and were very happy to see substantial performance gains, with no extra work required.

Ix.NET v7.0: .NET 10 and LINQ for IAsyncEnumerable<T>

Ian Griffiths26/11/2025

Ix.NET 7.0.0 is now available. Because .NET 10.0 now includes LINQ for IAsyncEnumerable, Ix.NET's System.Linq.Async has had to step back. This post explains what has changed and why.

Rx.NET v6.1 Now Available

Ian Griffiths03/10/2025

Rx.NET 6.1 is now available, adding some useful new features.

.NET Aspire: SQL persistence

Ian Griffiths04/06/2025

.NET Aspire can create new local instances of services such as SQL Server from scratch each time you run. While this guarantees repeatability and isolation, it can be time consuming, so this post explores alternatives.

.NET Aspire: using SqlConnection in integration tests

Ian Griffiths04/06/2025

.NET Aspire can create all of the resources an integration test required, but the test will often need direct access to the same SQL database as the code under test. This post shows how to do that.

.NET Aspire SQL Server integration tests and local development

Ian Griffiths04/06/2025

.NET Aspire can create local services such as a SQL Server to stand in for cloud resources under local development and testing. This post shows how to ensure such a database is suitably initialized.

.NET Aspire SQL Server integration tests

Ian Griffiths04/06/2025

.NET Aspire offers features enabling integration tests to use dev-time orchestration. This post shows how a test can use these.

.NET Aspire dev-time orchestration for SQL Server integration tests

Ian Griffiths04/06/2025

.NET Aspire's dev-time orchestration can be used to build integration tests that depend on a SQL Server database. This blog series explains how.

C# 12.0: ref readonly

Ian Griffiths16/04/2025

C# 12.0 adds a new way to annotate parameters: ref readonly. This seems like it should mean exactly the same as the older in annotation. This post explains why this new syntax is useful.

Spark dev containers: packaging code for testability

Ian Griffiths03/02/2025

Once you've thoroughly tested your code against the local Spark service in your dev container, you'll want to run it in a real Spark cluster. This posts shows how to deploy such code to Microsoft Fabric.

Spark dev containers: writing tests

Ian Griffiths24/01/2025

Having seen earlier in the series how to configure a dev container to run Spark locally, this post shows how to write tests that use that local Spark service.

Spark dev containers: running Spark locally

Ian Griffiths16/01/2025

See how to configure a dev container to run Spark locally, to improve development feedback loops.

Working locally with spark dev containers

Ian Griffiths10/01/2025

Running Spark locally in a dev container can significantly improve development feedback loops. This first article explains why, and the rest of the series will show how.

C# 12.0: collection expressions

Ian Griffiths08/01/2025

C# 12.0 provides a new, simpler syntax for initializing expressions. It typically generates the most efficient code possible, although as you'll see, it's useful to understand the choices it makes.

C# 12.0: inline arrays

Ian Griffiths26/11/2024

A new feature in C# 12.0 enables data types to define fixed-size arrays that don't require separate array objects on the heap. Learn how this is useful in performance-oriented and interop scenarios.

How .NET 9.0 boosted AIS.NET performance by 9%

Ian Griffiths15/11/2024

.NET 9.0 has shipped, and for the fourth year running, we benchmarked endjin's AIS.NET library and were very happy to see substantial performance gains, with no extra work required.

Modern Compute: Compute-Intensive Workloads

Ian Griffiths01/11/2024

We have a wide range of computational mechanisms at our disposal, some of which emerged thanks to recent advances in AI. In this post, we look at the kinds of workloads that can take advantage of these.

C# 12.0: primary constructors

Ian Griffiths29/10/2024

C# 12.0's most prominent new feature is the primary constructor syntax. This post describes how it works, and looks at some pros and cons.

Modern Compute: Unavoidable Practicalities

Ian Griffiths03/10/2024

Thanks in part to recent advances in AI, we have a range of computational mechanisms at our disposal. However, certain universal truths apply to all of them.

C# 11.0 new features: ref fields and the scoped keyword

Ian Griffiths16/09/2024

C# 11.0 expanded high-performance, low-allocation functionality. This post describes the importance of the added support for ref fields, and how the scoped keyword relates.

After the AI Storm: Modern Compute

Ian Griffiths09/09/2024

AI's current hype cycle has driven massive hardware investment. Even if AI disappoints, those hardware capabilities remain. What else can we do with them?

Per-Property Rows from JSON in Spark on Microsoft Fabric

Ian Griffiths23/08/2024

Spark doesn't always interpret JSON how we'd like. For example, if each key/value pair in a JSON object is conceptually one item, Spark won't give you a row per item by default. This article shows how to nudge Spark in the right direction.

.NET JsonElement and Schema Validation

Ian Griffiths24/04/2024

Corvus.JsonSchema enables safe use of the very high performance JSON parsing offered by .NET's System.Text.Json.

.NET JsonElement Error Handling

Ian Griffiths23/02/2024

.NET's System.Text.Json offers very high performance JSON parsing. However, JsonElement's text parsing methods offer a trap for the unwary

Analyzing WPF performance by enabling ETW

Ian Griffiths12/01/2024

WPF makes extensive performance instrumentation available through ETW. However, in modern .NET, it's not obvious how to get hold of it. This blog shows how

ASP.NET Core 8.0 uses C# 12.0's experimental interceptors to enable AOT

Ian Griffiths09/01/2024

C# 12 includes an experimental 'interceptors' feature. If you use trimming or AOT publishing in ASP.NET Core 8.0, you're already using this.

Boosting string search performance in .NET 8.0 with SearchValues

Ian Griffiths03/01/2024

Learn how .NET 8.0's SearchValues<T> can speed up string searching

How .NET 8.0 boosted AIS.NET performance by 27%

Ian Griffiths29/11/2023

When we benchmarked endjin's AIS.NET library on .NET 8.0, we were delighted to see substantial performance gains, with no extra work required.

How .NET 7.0 boosted AIS.NET performance by 19%

Ian Griffiths24/08/2023

When we benchmarked endjin's AIS.NET library on .NET 7.0, we were delighted to see substantial performance gains, with no extra work required.

Rx.NET v6.0 Now Available

Ian Griffiths19/05/2023

For the first time since 2020, a new release of Rx.NET is available, supporting .NET 6 and .NET 7.

C# 11.0 new features: Span<char> pattern matching

Ian Griffiths05/04/2023

C# 11.0 adds some new pattern matching features. In this post, Ian shows the new support for matching lists.

C# 11.0 new features: list pattern matching

Ian Griffiths10/03/2023

C# 11.0 adds some new pattern matching features. In this post, Ian shows the new support for matching lists.

C# 11.0 new features: newlines in string interpolation expressions

Ian Griffiths23/02/2023

C# 11.0 enhances string literals with new features. Discover how multiline interpolated strings boost readability in Ian's insightful post.

C# 11.0 new features: UTF-8 string literals

Ian Griffiths15/02/2023

C# 11.0 adds various improvements to string literals. In this post, Ian explains how we can now create UTF-8 string literals.

C# 11.0 new features: raw string literals

Ian Griffiths01/02/2023

C# 11.0 adds various improvements to string literals. In this post, Ian explains how raw string literals can make your code more readable.

Lazy and once-only C# async initialization

Ian Griffiths10/01/2023

Performing lazy and/or just-once initialization is a simple optimization. But what if the initialization is async?

In Defence of Squash Commits

Ian Griffiths22/11/2022

Encapsulation is a powerful tool. Squash commits provide a way to encapsulate Git commit history.

C# Lambda Discards

Ian Griffiths12/09/2022

C# has gradually been adding support for discards. This article explores how this evolution has led to some surprises.

Excel, data loss, IEEE754, and precision

Ian Griffiths05/07/2022

Explore the impact of Excel's numeric precision rules on identifiers and learn about infamous data loss incidents caused by misuse in this post.

C# 11.0 preview: parameter null checking

Ian Griffiths16/02/2022

Discover C# 11.0's new !! syntax for detecting & rejecting null arguments. Learn its true purpose and clear up common misconceptions in this post.

C# 10.0 improves handling of nullable references in generic types - no more AllowNull

Ian Griffiths08/02/2022

Explore C# 10.0's improved nullability annotations in generic code, replacing AllowNull with more intuitive syntax.

Raising Coding Standards with .NET 6.0 Code Analyzers

Ian Griffiths25/01/2022

.NET 6.0 makes it easier to take full advantage of code analyzers that can help you improve the quality of your code.

How .NET 6.0 boosted Ais.Net performance by 20%

Ian Griffiths06/01/2022

When we tested endjin's AIS.NET library on .NET 6.0, we were delighted to see substantial performance gains, with no extra work required.

How C# 10.0 and .NET 6.0 improve ArgumentExceptions

Ian Griffiths12/11/2021

C# 10.0's support for CallerArgumentExpression and some new helpers in .NET 6.0 make throwing argument exceptions more succinct and less error prone.

C# 10.0 implicit global using directives

Ian Griffiths20/09/2021

C# 10's new implicit global imports can make your code more communicative. This article shows how the magic works, and how you can control the feature.

How Azure Synapse unifies your development experience

Ian Griffiths11/12/2020

Modern analytics requires a multi-faceted approach, which can cause integration headaches. Azure Synapse's Swiss army knife approach can remove a lot of friction.

When C# 9.0 patterns go wrong: mechanism over intent

Ian Griffiths01/12/2020

C# 9 enhances pattern matching capabilities. Ian Griffiths advises caution to avoid complexity.

C# 8.0 nullable references: defeating the point with empty strings

Ian Griffiths20/10/2020

Enabling C# 8's nullable references feature often produces a lot of warnings. Avoid the temptation to make some go away by initializing properties to empty strings.

C# 8.0 nullable references: prepare today by not misusing 'as'

Ian Griffiths07/10/2020

Prepare for using C# 8.0 nullable references by not misusing the 'as' operator.

ArrayPool vs MemoryPool—minimizing allocations in AIS.NET

Ian Griffiths28/09/2020

Tracking down unexpected allocations in a high-performance .NET parsing library.

C# 8.0 nullable references and serialization

Ian Griffiths23/09/2020

C# 8's nullable references feature can clash with common serialization techniques. This article shows how to deal with that.

C# 8.0 nullable references: when methods don't return

Ian Griffiths06/08/2020

Explore the importance of DoesNotReturn & DoesNotReturnIf attributes in C# 8 nullable references, enhancing their long-standing role in C#.

Reactive Extensions for .NET at dotnetsheff

Ian Griffiths31/07/2020

Ian Griffiths is talking about the Reactive Extensions for .NET at dotnetsheff. Learn the ideas behind Rx, and see it applied in an IoT applicable to upload clinical monitoring data to the cloud.

C# 8.0 nullable references: supporting older runtimes

Ian Griffiths20/07/2020

See how to use C# 8.0 nullable references even when targetting older versions of .NET that don't officially support it.

C# 8.0 nullable references: more type system transcendence with DisallowNull

Ian Griffiths14/07/2020

C# 8.0 nullable references help identify potential null-related bugs. DisallowNull attribute enhances properties and generics.

C# 8.0 nullable references: conditional post-conditions

Ian Griffiths10/07/2020

Explore C#8's NotNullWhen, MaybeNullWhen, & NotNullIfNotNull attributes for improved nullability warnings, aiding method output inference from inputs.

C# 8.0 nullable references: MaybeNull

Ian Griffiths03/07/2020

The MaybeNull attribute enables C#8's nullable references feature to provide more useful warnings, by helping it infer information about a method output.

C# 8.0 nullable references: NotNull

Ian Griffiths26/06/2020

The NotNull attribute enables C#8's nullable references feature to provide more useful warnings, by helping it infer information about a method argument.

C# 8.0 nullable references: transcending the type system with AllowNull

Ian Griffiths18/05/2020

Explore C# 8.0 nullable references & AllowNull attribute for better null-related bug detection and enhanced expressiveness in properties & generics.

C# 8.0 nullable references: get better results with nullability attributes

Ian Griffiths13/05/2020

C# 8.0 nullable references enable us to annotate our code with information that lets the compiler discover possible null-related bugs.

C# 8.0 nullable references: getting started in an existing codebase

Ian Griffiths06/05/2020

C# 8.0's nullable references feature dramatically changes a fundamental aspect of the language. In this post, Ian explains how to you can soften the impact by enabling gradually across your projects.

C# 8.0 nullable references: inferred (non-)nullness

Ian Griffiths28/04/2020

Ian discusses inferred nullness and its significance in C# 8.0's new Nullable References feature.

C# 8.0 nullable references: embrace the expressiveness

Ian Griffiths21/04/2020

C# 8.0 nullable references detect null-related errors and enhance code expressiveness.

C# 8.0 nullable references: non-nullable is the new default

Ian Griffiths14/04/2020

Explore C# 8.0's nullable references feature, as Ian discusses its impact on default nullability assumptions in this informative post.

C# teamwork: share project config with common Nuget Build Asset Packages

Ian Griffiths08/04/2020

See how to manage consistent default configuration across all your .NET projects by using NuGet build assets.

High-performance C#: a test pattern for ref structs

Ian Griffiths25/03/2020

Explore C# 7.2's ref structs, use in high-performance scenarios, their constraints, and techniques for overcoming challenges in unit testing the Ais.Net parser.

Introducing Ais.Net - High-Performance Parsing in C#

Ian Griffiths18/03/2020

Explore endjin's high-performance .NET AIS parser, developed for OceanMind, used for tracking commercial ships.

Why You Should Buy My Book: Programming C# 8.0

Ian Griffiths09/03/2020

Ian spent a big chunk of last year writing an update to his book, Programming C# 8.0. Books continue to be Ian's preferred source of learning because nothing else offers the combination of depth, breadth, and coherence. His goal with Programming C# 8.0 (and its predecessors) was very clear: to write the book that he would want to read if he were learning C# today. It is Ian's attempt to distil around 18 years of experience with C# (part of almost 30 years of work as a programmer) into a coherent, complete description of what you'll need to know to be productive today in C#.

NDC London Day 1

Ian Griffiths05/02/2020

In this post, Ian describes some of the highlights from the NDC London conference

AI for Good Hackathon

Ian Griffiths21/01/2020

Endjin attended Microsoft's AI for Good hackathon at the IET in London, highlighting the potential of tech to amplify good deeds.

C# 8 Positional Patterns Custom Deconstructor Pitfall

Ian Griffiths21/10/2019

Discover 'positional patterns' in C# 8, their interaction with custom desconstructors, and unexpected behaviors.

C#, Span and async

Ian Griffiths17/10/2019

Explore how ref struct types like Span<T> in C# enhance performance but pose async method challenges, and learn mitigation techniques.

C# faux amis 3: variable declarations and type patterns

Ian Griffiths28/02/2019

Ian Griffiths discusses C# 8 features, highlighting how 'var' can enhance compile-time type checking in his final series article.

C# faux amis 2: tuple deconstruction and positional patterns

Ian Griffiths27/02/2019

C# v8.0 introduces various new patterns. In this article, part of a series on how the evolution of the language has added complexity, Ian Griffiths shows how the strong resemblance between the new Positional Patterns and Deconstruction can be misleading.

C# faux amis 1: discards and underscores

Ian Griffiths26/02/2019

Visual Studio 2019 saw the arrival of C# v8.0. This article shows the first of a series of examples of how friction can arise when integrating new features into a mature language: the relatively late addition of 'discards' causes some surprises.

C# 8 surprising patterns

Ian Griffiths26/02/2019

Visual Studio 2019 saw the arrival of C# v8.0. A programming language cannot evolve for 20 years without developing a few quirks. Ian Griffiths writes about a surprising aspect of the new pattern matching features, and what this reveals about how the language has changed.

A conversation about .NET, The Cloud, Data & AI, teaching software engineers and joining endjin with Ian Griffiths

Ian Griffiths31/12/2018

When he joined endjin, Technical Fellow Ian sat down with founder Howard for a Q&A session. This was originally published on LinkedIn in 5 parts, but is republished here, in full. Ian talks about his path into computing, some highlights of his career, the evolution of the .NET ecosystem, AI, and the software engineering life.

Async pitfalls: deferred work and resource ownership

Ian Griffiths21/09/2018

Combining deferred execution with asynchronous operations can cause subtle problems. This post shows how to ensure correct operation when these idioms combine.