Skip to content
Skills Library
Programming · Building & coding

dotnet-csharp

/dotnet-csharp

Baseline C# skill loaded for every .NET code path. Guides language patterns (records, pattern matching, primary constructors, C# 8-15), coding standards, async/await, DI, LINQ, serialization, domain modeling, concurrency, Roslyn analyzers, globalization, native interop (P/Invoke, LibraryImport, ComWrappers), WASM interop (JSImport/JSExport), and type design. Spans 27 topics. Do not use for ASP.NET endpoint architecture, UI framework patterns, or CI/CD guidance.

Licence
MIT
Last repository change
31.05.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
28
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 31.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Baseline C# skill loaded for every .NET code path. Guides language patterns (records, pattern matching, primary constructors, C# 8-15), coding standards, async/await, DI, LINQ, serialization, domain modeling, concurrency, Roslyn analyzers, globalization, native interop (P/Invoke, LibraryImport, ComWrappers), WASM interop (JSImport/JSExport), and type design. Spans 27 topics. Do not use for ASP.NET endpoint architecture, UI framework patterns, or CI/CD guidance.

Original author description

Baseline C# skill loaded for every .NET code path. Guides language patterns (records, pattern matching, primary constructors, C# 8-15), coding standards, async/await, DI, LINQ, serialization, domain modeling, concurrency, Roslyn analyzers, globalization, native interop (P/Invoke, LibraryImport, ComWrappers), WASM interop (JSImport/JSExport), and type design. Spans 27 topics. Do not use for ASP.NET endpoint architecture, UI framework patterns, or CI/CD guidance.

How it works

  1. Overview
  2. Routing Table
  3. Scope
  4. Out of scope
Original SKILL.md headings · 75 lines, 826 words
SKILL.md preview
---
name: dotnet-csharp
description: Baseline C# skill loaded for every .NET code path. Guides language patterns (records, pattern matching, primary constructors, C# 8-15), coding standards, async/await, DI, LINQ, serialization, domain modeling, concurrency, Roslyn analyzers, globalization, native interop (P/Invoke, LibraryImport, ComWrappers), WASM interop (JSImport/JSExport), and type design. Spans 27 topics. Do not use for ASP.NET endpoint architecture, UI framework patterns, or CI/CD guidance.
license: MIT
user-invocable: false
---

# dotnet-csharp

## Overview

C# language patterns, coding standards, and .NET runtime features for idiomatic, performant code. This consolidated skill spans 25 topic areas. Load the appropriate companion file from `references/` based on the routing table below.

### Always-Load Baseline

These references define correctness and quality standards that apply to all C# code — load them by default whenever producing or reviewing code, regardless of what the user asked for:

> **Path resolution note**: The filenames below are relative to the  subdirectory of this skill. The Read tool needs an absolute path. Use Glob to locate each file (pattern: ), then pass the absolute path to Read.  and  are in the parent  directory — Glob for  and .

-  — naming conventions, file layout, style rules
-  — async/await correctness, ConfigureAwait, cancellation propagation (nearly all .NET code uses async)
-  — SOLID, DRY, single responsibility, dependency inversion, anti-pattern detection
-  — common mistakes the agent should avoid without being told (async void, DI lifetime misuse, swallowed exceptions)
-  — side-by-side BAD/GOOD code: DateTime.Now→TimeProvider, N+1 queries, DI lifetime mismatch, .Result deadlocks, CancellationToken propagation
-  — always prefer free/open-source: MediatR→Mediator(MIT), FluentValidation→AddValidation(), AutoMapper→Mapperly, Newtonsoft→STJ, Swashbuckle→Microsoft.AspNetCore.OpenApi
-  — when to use what: consolidated decision guides for architecture, data access, caching, DI, observability, testing, deployment (Glob: )
-  — one-page summary of all non-negotiable rules, patterns, and package alternatives (Glob: )
-  — .NET 10/11 and C# 14/15 features, version matrix, TFM-specific code generation rules

### On-Demand References

Load these when the topic matches (see Routing Table keywords):

## Routing Table

| Topic | Keywords | Description | Companion File |
|-------|----------|-------------|----------------|
| Coding standards | naming, file layout, style rules | Baseline C# conventions (naming, layout, style rules) | references/coding-standards.md |
| Async/await | async, Task, ConfigureAwait, cancellation | async/await, Task patterns, ConfigureAwait, cancellation | references/async-patterns.md |
| Dependency injection | DI, services, scopes, keyed, lifetimes | MS DI, keyed services, scopes, decoration, lifetimes | references/dependency-injection.md |
| Configuration | Options pattern, user secrets, feature flags | Options pattern, user secrets, feature flags, IOptions\<T\> | references/configuration.md |
| Source generators | IIncrementalGenerator, GeneratedRegex, LoggerMessage | IIncrementalGenerator, GeneratedRegex, LoggerMessage, STJ | references/source-generators.md |
| Nullable reference types | annotations, migration, agent mistakes | Annotation strategies, migration, agent mistakes | references/nullable-reference-types.md |
| Serialization | System.Text.Json, Protobuf, MessagePack, AOT | System.Text.Json source generators, Protobuf, MessagePack | references/serialization.md |
| Channels | Channel\<T\>, bounded/unbounded, backpressure | Channel\<T\>, bounded/unbounded, backpressure, drain | references/channels.md |
| LINQ optimization | IQueryable vs IEnumerable, compiled queries | IQueryable vs IEnumerable, compiled queries, allocations | references/linq-optimization.md |
| Domain modeling | aggregates, value objects, domain events | Aggregates, value objects, domain events, repositories | references/domain-modeling.md |
| SOLID principles | SRP, DRY, anti-patterns, compliance checks | SOLID and DRY principles, C# anti-patterns, fixes | references/solid-principles.md |
| Concurrency | lock, SemaphoreSlim, Interlocked, concurrent collections | lock, SemaphoreSlim, Interlocked, concurrent collections | references/concurrency-patterns.md |
| Roslyn analyzers | DiagnosticAnalyzer, CodeFixProvider, multi-version | DiagnosticAnalyzer, CodeFixProvider, CodeRefactoring | references/roslyn-analyzers.md |
| Editorconfig | IDE/CA severity, AnalysisLevel, globalconfig | IDE/CA severity, AnalysisLevel, globalconfig, enforcement | references/editorconfig.md |
| File I/O | FileStream, RandomAccess, FileSystemWatcher, paths | FileStream, RandomAccess, FileSystemWatcher, MemoryMappedFile | references/file-io.md |
| Native interop | P/Invoke, LibraryImport, ComWrappers, marshalling | P/Invoke, LibraryImport, ComWrappers, marshalling, cross-platform | references/native-interop.md |
| Input validation | .NET 10 AddValidation, DataAnnotations | .NET 10 AddValidation, DataAnnotations, ProblemDetails | references/input-validation.md |
| Validation patterns | DataAnnotations, IValidatableObject, IValidateOptions | DataAnnotations, IValidatableObject, IValidateOptions\<T\> | references/validation-patterns.md |
| Modern patterns | records, pattern matching, primary constructors | Records, pattern matching, primary constructors, C# 12-15 | references/modern-patterns.md |
| API design | naming, parameter ordering, return types, extensions | Naming, parameter ordering, return types, error patterns | references/api-design.md |
| Type design/perf | struct vs class, sealed, Span/Memory, collections | struct vs class, sealed, Span/Memory, collections | references/type-design-performance.md |
| Code smells | anti-patterns, async misuse, DI mistakes, fixes | Anti-patterns, async misuse, DI mistakes, fixes | references/code-smells.md |
| .NET releases | .NET 10, .NET 11, C# 14, C# 15, TFM, version, union, extension blocks, field keyword | Version matrix, new features, TFM-specific code generation | references/dotnet-releases.md |
| Globalization | CultureInfo, StringComparison, TimeZoneInfo, Rune, encoding | Culture-aware coding, string comparison, time zones, character processing | references/globalization.md |
| WASM interop | JSImport, JSExport, standalone WASM, wasm-experimental, browser | JSImport/JSExport, standalone .NET WASM, browser APIs, WASM AOT | references/wasm-interop.md |

## Scope

- C# language features (C# 8-15)
- .NET runtime patterns (async, DI, config, serialization, channels, LINQ)
- Code quality (analyzers, editorconfig, code smells, SOLID)
- Type design and domain modeling
- File I/O and native interop
- Globalization (string comparison, CultureInfo, time zones, character processing, encoding)
- Input validation at the model level (DataAnnotations, IValidatableObject, Options validation)

## Out of scope

- ASP.NET Core / web API patterns (request-level validation, endpoint filters) -> [skill:dotnet-api]
- UI framework patterns -> [skill:dotnet-ui]
- Testing patterns -> [skill:dotnet-testing]
- Build/MSBuild/project setup -> [skill:dotnet-tooling]
- Performance profiling tools -> [skill:dotnet-tooling]
Files in this package (28)
  • SKILL.md 7 KB
  • references/anti-patterns.md 5 KB
  • references/api-design.md 15 KB
  • references/async-patterns.md 10 KB
  • references/channels.md 16 KB
  • references/code-smells.md 17 KB
  • references/coding-standards.md 5 KB
  • references/concurrency-patterns.md 15 KB
  • references/configuration.md 14 KB
  • references/dependency-injection.md 11 KB
  • references/domain-modeling.md 21 KB
  • references/dotnet-releases.md 7 KB
  • references/editorconfig.md 16 KB
  • references/file-io.md 18 KB
  • references/globalization.md 15 KB
  • references/input-validation.md 19 KB
  • references/linq-optimization.md 14 KB
  • references/modern-patterns.md 12 KB
  • references/native-interop.md 19 KB
  • references/nullable-reference-types.md 9 KB
  • references/package-choices.md 3 KB
  • references/roslyn-analyzers.md 22 KB
  • references/serialization.md 14 KB
  • references/solid-principles.md 16 KB
  • references/source-generators.md 18 KB
  • references/type-design-performance.md 13 KB
  • references/validation-patterns.md 19 KB
  • references/wasm-interop.md 11 KB

Versions

RepositoryScoreLicence
This page · fenzel999/dotnet-artisan90MIT
novotnyllc/dotnet-artisan90MIT

Database snapshot: 13.11.2026 · package version a21a1ca8fc00 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100csharp-expert
    Expert-level C# development with .NET 8+, ASP.NET Core, LINQ, async/await, and enterprise patterns. Use when the user mentions C#, .NET, ASP.NET, enterprise, or Microsoft platforms, or when the task involves Modern C#, Async/Await, LINQ, or ASP.NET Core.
  • 95lang-csharp
    Use this skill when the user says 'C#', 'csharp', '.NET', 'dotnet', 'async await C#', 'LINQ', 'nullable reference types', 'Span<T>', 'records', 'pattern matching', 'IDisposable', 'xUnit', 'NuGet', 'dotnet CLI'. Writes and reviews modern C# on current .NET (LTS .NET 10): language…
  • 100csharp
    Expert C# and .NET assistance covering LINQ, async/await patterns, pattern matching, records, Entity Framework Core, and ASP.NET Core web services. Use when writing idiomatic C#, designing .NET enterprise backends, building cross-platform services, or optimizing memory with span/memory types.
  • 95csharp
    C# 12 language features including records, pattern matching, nullable reference types, LINQ, async/await, and modern language patterns. USE WHEN: user mentions "C#", "C# records", "pattern matching", "LINQ", "async/await", "nullable reference types", "C# generics", "C# language…
  • 100csharp-idioms
    Modern C# (10+/.NET) coding idioms: nullable reference types, records, pattern matching, async/await with CancellationTokens, LINQ performance, and DI. Use when writing, modifying, or reviewing C# application code or domain models. Pair with dotnet-idioms for framework APIs.
  • 100csharp-linq-modern-dotnet
    Use this skill when writing clean, expressive data transformations using C# LINQ query syntax, records, and pattern matching.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.