C#
Target C# 14, which ships with .NET 10. Use a new feature where it replaces an older idiom, not everywhere it compiles.
Opinions
Extension members
Use extension blocks instead of static classes of this-parameter methods. A C# 14 extension block declares the receiver once for every member in it. It also allows extension properties and operators, which the this-parameter syntax can't express.
Before (C# 13 and earlier):
public static class OrderExtensions
{
public static bool IsOpen(this Order order) => order.ClosedAt is null;
public static decimal Total(this Order order) => order.Lines.Sum(l => l.Price);
}
After (C# 14):
public static class OrderExtensions
{
extension(Order order)
{
public bool IsOpen => order.ClosedAt is null;
public decimal Total => order.Lines.Sum(l => l.Price);
}
}
- Use an extension member for a pure query or transform over a type you don't own. For a type you own, write an instance method. The exception is a domain entity you keep as plain data, with validation, formatting, and mapping outside it.
- Use a property when the member states a fact about the instance.
IsEmptyandWordCountread naturally as properties and awkwardly as calls. - Convert a method to a property only while you're already changing its callers. The conversion breaks every call site.
(.NET Blog: Introducing C# 14, Microsoft Learn: What's new in C# 14, .NET Blog: C# 14 - Exploring extension members, Microsoft Learn: Extension methods design guidelines, dotnet/csharplang: Extension members)
The field keyword
When an accessor needs validation, normalisation, or lazy logic, use the field keyword instead of a hand-written backing field. Declare an explicit field only when code outside the accessors uses it. Without a named field, no other member can write the value and skip the accessor.
Before:
public class Sensor
{
private string _name = "";
public string Name
{
get => _name;
set => _name = value.Trim();
}
}
After:
(.NET Blog: Introducing C# 14, dotnet/csharplang: field keyword in properties)
Null-conditional assignment
Use null-conditional assignment (obj?.Property = value) instead of an if (obj is not null) guard. The right-hand side runs only when the receiver isn't null, so the rewrite behaves exactly like the guard.
Before:
After:
(.NET Blog: Introducing C# 14, dotnet/csharplang: Null-conditional assignment)
Pattern matching
Check for null with is null and is not null, and use a switch expression when each branch produces a value. An overloaded == or != can't change the result of an is pattern. A switch expression with property, relational, and type patterns replaces an if/else chain with one table. The compiler reports CS8509 when an input isn't handled.
public static decimal DiscountFor(Customer customer) => customer switch
{
{ Tier: Tier.Gold, YearsActive: >= 5 } => 0.20m,
{ Tier: Tier.Gold } => 0.10m,
{ Tier: Tier.Silver } => 0.05m,
_ => 0m,
};
Arms match from top to bottom, so put the most specific first. Keep a two-way if as an if.
(Microsoft Learn: Pattern matching)
Collection expressions
Create and combine collections with collection expressions ([...]), not a constructor with an initializer or a Concat().ToArray() chain. One syntax covers arrays, List<T>, spans, and immutable collections. The compiler picks the cheapest construction for the target type, and the spread element .. replaces allocating concatenation.
Before:
After:
The target type must be explicit: List<int> ids = [...], not var ids = [...].
(Microsoft Learn: Collection expressions)
Records
Keep a record to the data it's constructed from: no derived state, and no collection members. The generated members behave as the syntax suggests only when every property is a constructor parameter stored unchanged. Catch these two cases in review:
-
A property initialized from a parameter goes stale under
with.withdoesn't re-run the constructor. It lowers to roughlyvar copy = original.<Clone>$(); copy.Value = 3;, and the copy constructor copies every field before the assignments run. A property computed at construction keeps its old value whenwithchanges the parameter it came from. (Skeet: Unexpected inconsistency in records, Skeet: Records and thewithoperator, redux)// Wrong: Even is computed once, at construction public sealed record Number(int Value) { public bool Even { get; } = (Value & 1) == 0; } var n3 = new Number(2) with { Value = 3 }; // Number { Value = 3, Even = True } // Right: derived on read, so it always follows Value public sealed record Number(int Value) { public bool Even => (Value & 1) == 0; } -
A collection member breaks value equality. The generated
Equalscompares members withEqualityComparer<T>.Default.ImmutableList<T>and the other immutable collections don't overrideEquals, so they compare by reference, and two records with identical contents aren't equal. Use a collection member only when you want reference equality, such as instances shared within one object graph. Otherwise, keep the collection outside the record, or document that equality means identity. (Skeet: Records and Collections)
Nullable reference types
Enable nullable reference types in every project, and make nullable warnings errors. Set <Nullable>enable</Nullable> and <WarningsAsErrors>nullable</WarningsAsErrors> in Directory.Build.props.
- Never use
#nullable disablein new code. - Use the null-forgiving operator
!only where flow analysis can't see the value, such as a property a serializer or test setup fills in. Justify every!in review. - Keep
ArgumentNullException.ThrowIfNullat public API boundaries. Annotations exist only at compile time, so they don't stop unannotated or reflection-based callers.
(Microsoft Learn: Nullable reference types)
Analyzers
Set the built-in analyzers to latest-recommended, enforce code style in the build, and add Meziantou.Analyzer. In Directory.Build.props:
<PropertyGroup>
<AnalysisLevel>latest-recommended</AnalysisLevel>
<EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
</PropertyGroup>
latest-recommended: Picks up new rules with each SDK, without the noise ofall.EnforceCodeStyleInBuild: Reports.editorconfigstyle rules (IDExxxx) in the build, not only in the IDE, so CI and editors agree.- Meziantou.Analyzer: Adds correctness rules the SDK lacks, such as culture-sensitive string operations,
CancellationTokenforwarding, and async mistakes. Add other analyzers alongside it for rules it doesn't cover. Skip StyleCop ifdotnet formatalready enforces your formatting.
Fix each diagnostic, or suppress it with a written justification. Never lower severity across the board.
(Microsoft Learn: Code analysis overview, Meziantou: The Roslyn analyzers I use, Meziantou: Meziantou.Analyzer)
Smaller opinions
- Take
Span<T>andReadOnlySpan<T>parameters in new APIs. C# 14's implicit span conversions let callers pass arrays without an allocation. In .NET 10, span overloads win overload resolution in more cases, which is a breaking change. (Microsoft Learn: What's new in C# 14, Microsoft Learn: Breaking changes in .NET 10) - Use
nameof(List<>)on unbound generics instead of hard-coded type names in diagnostics and exceptions. (Microsoft Learn: What's new in C# 14) - Use
StringComparison.Ordinalfor every machine-facing comparison, andCultureInfo.InvariantCulturefor every machine-facing format or parse. Never useStringComparison.InvariantCulture: its collation isn't invariant. For details, see globalization.md. - Clone records with
with, and never declare an instanceClone()method. It conflicts with the compiler-generated clone. If you want a named method, wrapwithin an extension method. (Meziantou: Adding a Clone method to a C# record)
Coming next (preview, not yet the opinion)
.NET 11 previews add union types and closed class hierarchies, with compile-time exhaustiveness checks. Add them to the opinions when .NET 11 reaches GA. (Lock: .NET (OK, C#) finally gets union types, Lock: Closed class hierarchies)