dotnet10-csharp14

Files (1)

• SKILL.md

SKILL.md (first lines)

# .NET 10 + C# 14 Best Practices

## When to Use

Use this skill when:
- Writing or reviewing .NET 10 / C# 14 code
- Deciding whether to adopt a new C# 14 feature
- Modernizing .NET projects without rewriting stable code unnecessarily
- Reviewing ASP.NET Core 10, EF Core 10, or runtime-related changes

Always combine this with the repo's own `docs/STANDARDS.md` and the generic `csharp-dotnet` skill when broader .NET architecture guidance is needed.

## Adoption Rule

> Use .NET 10 / C# 14 features only when they improve clarity, safety, maintainability, or performance. Do not rewrite working code just to use new syntax.

Before adopting new features, verify:
- [ ] The project targets .NET 10 and LangVersion supports C# 14
- [ ] CI/build images have the .NET 10 SDK installed
- [ ] Team/editor tooling supports the syntax
- [ ] Existing tests still pass
- [ ] The feature fits the project's architecture and style guide

## C# 14 Features Worth Using

### 1. `field` keyword — validated properties without explicit backing field

Use when a property needs simple validation or normalization in the setter.

```csharp
public string Name
{
    get;
    set => field = string.IsNullOrWhiteSpace(value)
        ? throw new ArgumentException("Name is required.", nameof(value))
        : value.Trim();
}
```

Good fits:
- Small invariants on DTOs or domain objects
- Normalization such as trimming strings
- Replacing trivial private backing fields

Avoid when:
- Validation belongs in FluentValidation or another validation layer
- The setter becomes complex
- The class already has a member named `field`; use `@field` or rename to avoid confusion

### 2. Null-conditional assignment — `?.=`

Use when assigning only if the target exists; right-hand side is not evaluated if the receiver is null.

```csharp
currentUser?.LastSeenAt = clock.UtcNow;
```

Good fits:
- Optional state updates
- Defensive assignments in mapping code
- Optional telemetry/log enrichment

Avoid when:
- Null should be treated as an error
- Assignment hides an unexpected missing dependency
- Increment/decrement is needed (`++` / `--` are not supported)

### 3. Extension members — extension properties and static extension methods

Use for tiny, broadly useful helpers where fluent/readable syntax matters.

```csharp
public static class CollectionExtensions
{
    extension<T>(IReadOnlyCollection<T> source)
    {
        public bool IsEmpty => source.Count == 0;
    }
}
```

Good fits:
- Small collection/string/result helpers
- Domain-specific readability improvements
- Avoiding repeated utility boilerplate

Avoid when:
- The extension hides expensive work
- A normal method would be clearer
- It encourages an anemic domain model by moving real behavior out of domain types

### 4. `nameof(List<>)` — unbound generic `nameof`

Use when referring to generic type names without inventing a type argument.

```csharp
var collectionType = nameof(List<>);        // "List"
var mapType = nameof(Dictionary<,>);        // "Dictionary"
```

Good fits:
- Diagnostics and exception messages
- Metadata or validation involving generic type definitions
- Source generators/analyzers

### 5. Partial constructors and partial events

Use to split generated and handwritten code safely.

```csharp
public partial class ReportBuilder
{
    partial void OnBuildFailed(Exception exception);
}
```

Good fits:
- Source generators
- Separating generated code from custom hooks

From CamiloAndresGTRUniandes/lucy-ai, Apache-2.0.

More from CamiloAndresGTRUniandes/lucy-ai