Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Using records, pattern matching, primary constructors, collection expressions. C# 12-15 by TFM.
dotnet-csharp-modern-patterns
Modern C# language feature guidance adapted to the project's target framework. Always run
[skill:dotnet-version-detection] first to determine TFM and C# version.
Naming and style conventions -- see [skill:dotnet-csharp-coding-standards]
Async/await patterns -- see [skill:dotnet-csharp-async-patterns]
Source generator usage (GeneratedRegex, LoggerMessage) -- see [skill:dotnet-csharp-source-generators]
Cross-references: [skill:dotnet-csharp-coding-standards] for naming/style conventions,
[skill:dotnet-csharp-async-patterns] for async-specific patterns.
Quick Reference: TFM to C# Version
TFM
C#
Key Language Features
net8.0
12
Primary constructors, collection expressions, alias any type
net9.0
13
params collections, Lock type, partial properties
net10.0
14
field keyword, extension blocks, nameof unbound generics
net11.0
15 (preview)
Collection expression with() arguments
Records
Use records for immutable data transfer objects, value semantics, and domain modeling where equality is based on values
rather than identity.
Record Classes (reference type)
// Positional record: concise, immutable, value equalitypublicrecordOrderSummary(int OrderId, decimal Total, DateOnly OrderDate);
// With additional memberspublicrecordCustomer(string Name, string Email)
{
publicstring DisplayName => $"{Name} <{Email}>";
}
```text
### Record Structs (value type, C# 10+)
```csharp
// Positional record struct: value type with value semanticspublicreadonlyrecordstructPoint(double X, double Y);
// Mutable record struct (rare -- prefer readonly)publicrecordstructMutablePoint(double X, double Y);
```text
### When to Use Records vs Classes
| Use Case | Prefer |
| ------------------------------------ | ------------------------ |
| DTOs, API responses | `record` |
| Domainvalueobjects (Money, Email) | `readonlyrecord ` |
| (, ) | `` |
| -, | ` ` |
| | `` (-) |
### -
```
= order { Total = order.Total + tax };
```csharp
---
Capture constructor parameters directly the / .
**** -- .
### ( )
```
( , <> )
{
{
logger.LogInformation(, id);
repo.GetByIdAsync(id);
}
}
```text
- Primary constructor parameters are **mutable** captures, `` fields. If immutability matters, assign to a
`` field the body.
- Do use primary constructors you need to validate parameters at construction time -- use a traditional
constructor guard clauses instead.
- For records, positional parameters become properties automatically. For classes/structs, they remain
captures.
```csharp
{
_connectionString = connectionString
?? ArgumentNullException((connectionString));
}
```text
---
Unified syntax creating collections `[...]`.
```csharp
[] numbers = [, , ];
List<> names = [, ];
ReadOnlySpan<> bytes = [, ];
[] combined = [..first, ..second, ];
List<> empty = [];
```text
Specify capacity, comparers, other constructor arguments:
```csharp
List<> nums = [(capacity: ), ..Generate()];
HashSet<> = [(comparer: StringComparer.OrdinalIgnoreCase), , ];
Dictionary<, > map = [(comparer: StringComparer.OrdinalIgnoreCase),
(, ), (, )];
```text
> **net11+ only.** Requires `<LangVersion>preview</LangVersion>`. Do use earlier TFMs.
---
``` => customer
{
{ Tier: , YearsActive: > } => ,
{ Tier: } => ,
{ Tier: } => ,
_ =>
};
```text
``` => data [> , .., > ];
=> values
{
[] => ,
[] => ,
[] =>
};
```text
``` => package
{
Letter { Weight: < } => m,
Parcel { Weight: w } w < => m + w * m,
Parcel { IsOversized: } => m,
_ => m
};
```text
---
Force callers to initialize properties at construction via initializers.
```csharp
{
Name { ; ; }
Email { ; ; }
? Phone { ; ; }
}
user = UserDto { Name = , Email = };
```
{
Reading
{
=> field;
=> field = >=
?
: ArgumentOutOfRangeException(());
}
}
```text
Replaces the manual pattern of declaring a field plus a property custom logic. Use you need validation
transformation a setter without a separate backing field.
> **net10+ only.** On earlier TFMs, use a traditional field.
---
Group extension members a type a single block.
```csharp
{
extension<T>(IEnumerable<T> source) T :
{
=> source.Where(x => x );
=> !source.Any();
}
}
```text
> **net10+ only.** On earlier TFMs, use traditional `` extension methods.
---
```csharp
Point = ( X, Y);
UserId = System.Guid;
Point origin = (, );
UserId id = UserId.NewGuid();
```text
Useful tuple aliases domain type aliases without creating a full type.
---
`` now supports additional collection types beyond arrays, including `Span<T>`, `ReadOnlySpan<T>`, types
implementing certain collection interfaces.
```
{
( msg messages)
Console.WriteLine(msg);
}
Log(, );
```text
> **net9+ only.** On net8, `` only supports arrays.
---
Use `System.Threading.Lock` instead of `` locking.
```csharp
Lock _lock = ();
{
(_lock)
{
}
}
```text
`Lock` provides a `Scope`-based API advanced scenarios more expressive than ` ()`.
> **net9+ only.** On net8, use ` _gate = ();` ` (_gate)`.
---
Partial properties enable source generators to define property signatures that users implement, vice versa.
```csharp
{
Name { ; ; }
}
{
_name = ;
Name
{
=> _name;
=> SetProperty( _name, );
}
}
```text
> **net9+ only.** See [skill:dotnet-csharp-source-generators] generator patterns.
---
```csharp
name = (List<>);
name2 = (Dictionary<,>);
```csharp
Useful logging, diagnostics, reflection scenarios.
> **net10+ only.**
---
When targeting multiple TFMs, newer language features may compile older targets. Use these approaches:
**PolySharp** -- Polyfills compiler- { => field; => field = Math.Max(, ); }
_value;
Value { => _value; => _value = Math.Max(, ); }
```text
See [skill:dotnet-multi-targeting] comprehensive polyfill guidance.
---
Feature guidance skill grounded publicly available language design rationale :
- **C
rationale relevant to skill: ; use
fields immutability needed. Source: https:
- **C
features. Source: https:
> **Note:** This skill applies publicly documented design rationale. It does represent speak the named
> sources.
**Primary approach:** Use Serena symbol operations efficient code navigation:
**Find definitions**: `serena_find_symbol` instead of text search
**Understand structure**: `serena_get_symbols_overview` organization
**Track references**: `serena_find_referencing_symbols` impact analysis
**Precise edits**: `serena_replace_symbol_body` clean modifications
**When to use Serena vs traditional tools:**
- ✅ **Use Serena**: Navigation, refactoring, dependency analysis, precise edits
- ✅ **Use Read/Grep**: Reading full files, pattern matching, simple text operations
- ✅ **Fallback**: If Serena unavailable, traditional tools work fine
**Example workflow:**
```text
Read: src/Services/OrderService.cs
Grep:
serena_find_symbol:
serena_get_symbols_overview:
```
- [C
- [Whats C
- [What
struct
Entities
with
identity
User
Order
class
High
throughput
small
data
readonly
record
struct
Inheritance
needed
record
class
based
Non
destructive
Mutation
csharp
var
updated
with
## Primary Constructors (C# 12+, net8.0+)
in
class
struct
body
Parameters
become
available
throughout
the
type
but
are
not
fields
or
properties
they
are
captured
state
For
Services
DI
injection
csharp
public
class
OrderService
IOrderRepository
repo
ILogger
OrderService
logger
publicasync Task<Order> GetAsync(int id)
"Fetching order {OrderId}"
return
await
### Gotchas
not
readonly
readonly
in
not
when
with
public
private
// Explicit readonly field when immutability matters
publicclassConfig(string connectionString)
private
readonly
string
throw
new
nameof
## Collection Expressions (C# 12+, net8.0+)
for
with
// Array
int
1
2
3
// List
string
"Alice"
"Bob"
// Span
byte
0x00
0xFF
// Spread operator
int
99
// Empty collection
int
### Collection Expression with Arguments (C# 15 preview, net11.0+)
or
// Capacity hint
int
with
1000
// Custom comparer
string
set
with
"Alice"
"bob"
// Dictionary with comparer
string
int
with
new
"key1"
1
new
"key2"
2
.0
not
on
## Pattern Matching
### Switch Expressions (C# 8+)
csharp
stringGetDiscount(Customer customer)
switch
"Gold"
5
"30%"
"Gold"
"20%"
"Silver"
"10%"
"0%"
### List Patterns (C# 11+)
csharp
boolIsValid(int[] data)
is
0
0
// first and last positive
stringDescribe(int[] values)
switch
"empty"
var single
$"single: {single}"
var first, .., var last
$"range: {first}..{last}"
### Type and Property Patterns
csharp
decimalCalculateShipping(object package)
switch
50
0.50
var
when
1000
5.00
0.01
true
25.00
10.00
## `required` Members (C# 11+)
object
public
class
UserDto
public
required
string
get
init
public
required
string
get
init
public
string
get
init
// Compiler enforces Name and Email
var
new
"Alice"
"alice@example.com"
text
Useful for DTOs that need to be deserialized (System.Text.Json honors `required` in .NET 8+).
---
## `field` Keyword (C# 14, net10.0+)
Access the compiler-generated backing field directly in property accessors.
```csharp
publicclass TemperatureSensor
// Callers: compiler may avoid heap allocation with span-based params
"hello"
"world"
.0
.0
params
## `Lock` Type (C# 13, net9.0+)
object
for
private
readonly
new
publicvoidDoWork()
lock
// thread-safe operation
for
and
is
lock
object
.0
.0
private
readonly
object
new
and
lock
## Partial Properties (C# 13, net9.0+)
or
// In generated file
public
partial
class
ViewModel
public
partial
string
get
set
// In user file
public
partial
class
ViewModel
private
string
""
public
partial
string
get
set
ref
value
.0
for
## `nameof` for Unbound Generic Types (C# 14, net10.0+)
string
nameof
// "List"
string
nameof
// "Dictionary"
in
and
.0
## Polyfill Guidance for Multi-Targeting
not
on
1.
requiredtypes (`IsExternalInit`, `RequiredMemberAttribute`, etc.) so language
features like `init`, `required`, and `record` work on older TFMs.
2. **Polyfill** -- Polyfills runtime APIs (e.g., `string.Contains(char)` for netstandard2.0).
3. **Conditional compilation** -- Use `#if` for features that cannot be polyfilled:
```csharp
#if NET10_0_OR_GREATER
// Use field keywordpublicdouble Value
get
set
0
value
#else
private
double
public
double
get
set
0
value
#endif
for
## Knowledge Sources
in
this
is
in
from
# Language Design Notes (Mads Torgersen et al.)** -- Design decisions behind each C# version's features. Key
this
primary constructors (reducing boilerplate for DI-heavy services), collection
expressions (unifying collection initialization syntax), `field` keyword (eliminating backing field ceremony), and
extension blocks (grouping extensions by target type). Each feature balances expressiveness with safety -- e.g.,
primary constructor parameters are intentionally mutable captures (notreadonly) to keep the feature simple
explicit
readonly
when
is
//github.com/dotnet/csharplang/tree/main/meetings
# Language Proposals Repository** -- Detailed specifications and design rationale for accepted and proposed
's new in C# 14](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14)
- [C# Language Design Notes](https://github.com/dotnet/csharplang/tree/main/meetings)
- [.NET Framework Design Guidelines](https://learn.microsoft.com/en-us/dotnet/standard/design-guidelines/)
