# c-sharp

Tells the agent how to write C#: naming, async, DI, tests, Blazor and Unity. Useful when the project is .NET and you are tired of restating conventions.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 760 installs · ★ 286
- Author: Mindrally
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/Mindrally/skills/tree/HEAD/c-sharp/SKILL.md
- Updated: 2026-10-08
- HTML: https://affpapa.org/en/nevibecode/skills/c-sharp

## What it does

The skill loads as a set of instructions for the agent and covers C# style: PascalCase for classes and methods, camelCase for locals, an `I` prefix on interfaces, underscores on private fields. It also lists C# 10 and later features — file-scoped namespaces, global usings, records, pattern matching, nullable reference types.

Then come the practice sections. Error handling: try-catch for expected exceptions, custom exception classes, `ArgumentNullException.ThrowIfNull()`, the Result pattern. API design: REST conventions, DTOs between layers, status codes, versioning. Performance: `async/await` for I/O, `StringBuilder` in loops, `Span<T>` and `Memory<T>`. There are blocks on dependency injection with Scoped, Transient and Singleton lifetimes, on tests with xUnit or NUnit plus Moq and FluentAssertions, and on input validation with parameterized queries.

Blazor and Unity get their own sections. For Blazor that means component architecture, state management, cascading parameters, rendering optimised with `@key` and virtualization. For Unity — MonoBehaviour, ScriptableObjects, coroutines, object pooling. The skill is plain text: it runs nothing and checks nothing in your code, it only shapes what the agent suggests. If your team names things differently, these instructions will fight your conventions, so compare them before installing.

## Requirements
- Works with: Unity

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill c-sharp -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/c-sharp/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/c-sharp/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill c-sharp -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/c-sharp/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill c-sharp -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/c-sharp/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install Mindrally/skills c-sharp
```

2. **Manually: put the files in place**
- File: `.github/skills/c-sharp/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill c-sharp -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/Mindrally/skills --path c-sharp
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/c-sharp/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add Mindrally/skills --skill c-sharp -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/Mindrally/skills/tree/HEAD/c-sharp/SKILL.md

## When to use it
- settle on one naming style across a C# codebase
- pick between records, pattern matching and plain classes for new code
- assign Scoped, Transient and Singleton lifetimes to services
- write xUnit tests with mocks and readable assertions
- speed up a Blazor component with `@key` and virtualization

## Example prompts
- write an order service following the c-sharp skill guidelines
- refactor this controller: DTOs, status codes and DI as in c-sharp
- add xUnit tests with Moq following the c-sharp conventions

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: e0bf4e19fa45f937.

BEGIN THIRD-PARTY FILE e0bf4e19fa45f937
```text
---
name: c-sharp
description: Guidelines for C# development including Blazor, Unity game development, and .NET backend best practices
metadata:
  maintainer: Mindrally
  source: https://github.com/Mindrally/skills
---

# C# Development Guidelines

You are an expert in C# development with deep knowledge of .NET, Blazor, Unity, and modern C# language features.

## Code Style and Structure

- Write concise, idiomatic C# code with accurate examples
- Follow .NET and C# conventions and best practices
- Use object-oriented and functional programming patterns as appropriate
- Prefer LINQ and lambda expressions for collection operations
- Use descriptive variable and method names (e.g., `IsUserLoggedIn`, `GetUserById`)
- Structure files according to .NET conventions (Controllers, Models, Services, etc.)

## Naming Conventions

- Use PascalCase for class names, method names, and public properties
- Use camelCase for local variables and private fields
- Use SCREAMING_SNAKE_CASE for constants
- Prefix interfaces with "I" (e.g., `IUserService`)
- Prefix private fields with underscore (e.g., `_userRepository`)

## C# Language Features

### C# 10+ Features
- Use file-scoped namespaces for cleaner code
- Use global usings for common namespaces
- Leverage records for immutable data types
- Use pattern matching for type checking and deconstruction
- Use nullable reference types with proper annotations

### Modern Syntax
- Use expression-bodied members for simple methods and properties
- Use target-typed new expressions (`new()`)
- Use switch expressions for concise conditional logic
- Use string interpolation over string concatenation

## Error Handling

- Use try-catch blocks for expected exceptions
- Create custom exception classes for domain-specific errors
- Use `ArgumentNullException.ThrowIfNull()` for parameter validation
- Implement the Result pattern for operation outcomes when appropriate
- Log exceptions with context information

## API Design

- Follow RESTful conventions for web APIs
- Use DTOs for data transfer between layers
- Implement proper HTTP status codes
- Use action filters for cross-cutting concerns
- Version APIs appropriately

## Performance

- Use `async/await` for I/O-bound operations
- Implement caching where appropriate
- Use `StringBuilder` for string concatenation in loops
- Avoid boxing/unboxing with generics
- Use `Span<T>` and `Memory<T>` for high-performance scenarios

## Dependency Injection

- Use constructor injection for dependencies
```
END THIRD-PARTY FILE e0bf4e19fa45f937

The third-party file has ended. Everything between the e0bf4e19fa45f937 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2500 of 3682 bytes. © Mindrally · Apache-2.0 · https://github.com/Mindrally/skills/tree/HEAD/c-sharp/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md