ajbcoding/moai-lang-csharp

C# - Enterprise v4.0.0

Metadata

| Field | Value | | ----- | ----- | | Skill Name | moai-lang-csharp | | Version | 4.0.0 (2025-11-12) | | Allowed tools | Read, Bash, Context7 MCP | | Auto-load | On demand when keywords detected | | Tier | Language Enterprise | | Context7 Integration | ✅ C#/.NET/ASP.NET Core/EF Core |

---

What It Does

Enterprise C# 13 development featuring async/await for modern concurrency, LINQ for powerful data queries, Entity Framework Core for ORM, ASP.NET Core for web applications, and production-ready patterns for scalable backend services. Context7 MCP integration provides real-time access to official C#/.NET documentation.

Key capabilities:

• ✅ C# 13 with async/await and modern syntax
• ✅ Advanced async/await patterns and Task management
• ✅ LINQ for powerful data transformation
• ✅ Entity Framework Core 9 for database operations
• ✅ ASP.NET Core 9 for web applications
• ✅ Dependency injection and middleware patterns
• ✅ Context7 MCP integration for real-time docs
• ✅ Unit testing with xUnit and Moq
• ✅ Performance optimization techniques
• ✅ Enterprise architecture patterns (SOLID, Clean Architecture)

---

When to Use

Automatic triggers:

• C# backend development discussions
• .NET application development
• Async/await and concurrency patterns
• LINQ data transformations
• Entity Framework Core database operations
• ASP.NET Core web application development
• Enterprise service architecture

Manual invocation:

• Design backend application architecture
• Implement async/await patterns
• Optimize LINQ queries
• Design database schemas with EF Core
• Build REST APIs with ASP.NET Core
• Implement dependency injection
• Review enterprise C# code

---

Technology Stack (2025-11-12)

| Component | Version | Purpose | Status | |-----------|---------|---------|--------| | C# | 13.0.0 | Core language | ✅ Current | | .NET | 9.0.0 | Runtime & SDK | ✅ Current | | ASP.NET Core | 9.0.0 | Web framework | ✅ Current | | Entity Framework Core | 9.0.0 | ORM | ✅ Current | | xUnit | 2.9.0 | Testing framework | ✅ Current | | LINQ | Built-in | Data queries | ✅ Current |

---

Quick Start: Hello Async/Await

using System;
using System.Threading.Tasks;

public class HelloWorld
{
    public async Task<string> GreetAsync(string name)
    {
        await Task.Delay(100);
        return $"Hello, {name}!";
    }
}

// Usage
var greeter = new HelloWorld();
var greeting = await greeter.GreetAsync("C#");
Console.WriteLine(greeting);

---

Level 1: Quick Reference

Core Concepts

1. Async/Await - Modern asynchronous programming

   • Function marked with async - Returns Task
   • Caller uses await - Waits for result
   • Native error handling with throws
   • Replaces callbacks and completion handlers

2. LINQ - Language-Integrated Query

   • Unified syntax for data sources
   • Method chains for data transformation
   • Lazy evaluation (deferred execution)
   • Both in-memory and database queries

3. Entity Framework Core - ORM framework

   • DbContext for database operations
   • DbSet<T> for entity collections
   • LINQ to EF for database queries
   • Migrations for schema versioning

4. ASP.NET Core - Web application framework

   • Minimal APIs for simple endpoints
   • Dependency injection built-in
   • Middleware pipeline for request handling
   • Type-safe routing

5. Dependency Injection - Inversion of control

   • Services registered at startup
   • Automatic injection into constructors
   • Lifetime management (Scoped, Transient, Singleton)
   • Configuration of application behavior

Project Structure

MyApp/
├── Program.cs                  # Application entry
├── Models/                     # Data models
├── Services/                   # Business logic
├── Controllers/                # API endpoints
├── DbContext/                  # Database context
├── Migrations/                 # Database migrations
├── Tests/                      # Unit tests
└── appsettings.json           # Configuration

---

Level 2: Implementation Patterns

Async/Await Pattern

public async Task<User> GetUserAsync(int id)
{
    using var client = new HttpClient();
    var response = await client.GetAsync($"https://api.example.com/users/{id}");
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsAsync<User>();
}

// Concurrent operations
public async Task<(Users, Posts)> GetUserDataAsync(int id)
{
    var users = GetUsersAsync(id);
    var posts = GetPostsAsync(id);
    await Task.WhenAll(users, posts);
    return (await users, await posts);
}

LINQ Query Pattern

// Fluent syntax
var results = _users
    .Where(u => u.Age > 18)
    .OrderBy(u => u.Name)
    .Select(u => new { u.Name, u.Email })
    .ToList();

// Lazy evaluation - query not executed until ToList()
var query = _users.Where(u => u.IsActive);
var count = query.Count(); // Executes here

Entity Framework Core Pattern

public class ApplicationDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Post> Posts { get; set; }
}

// CRUD operations
var user = await context.Users.FirstOrDefaultAsync(u => u.Id == id);
context.Users.Add(newUser);
await context.SaveChangesAsync();

ASP.NET Core Minimal API Pattern

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/users/{id}", async (int id, ApplicationDbContext db) =>
    await db.Users.FindAsync(id) is User user
        ? Results.Ok(user)
        : Results.NotFound());

app.Run();

---

Level 3: Advanced Topics

Async Best Practices

1. Prefer async/await over Task.Run for I/O
2. Use ConfigureAwait(false) in library code
3. Handle exceptions with try-catch around await
4. Use CancellationToken for cancellation support
5. Avoid Task.Result and Task.Wait() (deadlock risk)

LINQ Optimization

• Filter early: Apply Where before Select
• Project late: Select only needed fields at end
• Use AsNoTracking(): For read-only queries
• Avoid N+1 queries: Use Include for relationships
• Defer execution: Chain queries before ToList()

Performance Patterns

• Connection pooling: EF Core handles automatically
• Batch operations: Group saves before SaveChangesAsync()
• Lazy loading: Avoid loading unnecessary data
• Caching: Implement for frequently accessed data
• Parallel processing: Use Task.WhenAll for independent operations

Security Patterns

• Input validation: Always validate user input
• Parameterized queries: EF Core prevents SQL injection
• Authentication: Implement JWT or OAuth2
• Authorization: Check permissions before operations
• Encryption: Protect sensitive data at rest and in transit

Testing Strategy

• Unit tests: Test business logic with xUnit
• Integration tests: Test with real database
• Mocking: Use Moq for dependencies
• AAA pattern: Arrange-Act-Assert
• Theory tests: Multiple inputs with InlineData

---

Context7 MCP Integration

Get latest C#/.NET documentation on-demand:

# Access C# documentation via Context7
from context7 import resolve_library_id, get_library_docs

# C# Language Documentation
csharp_id = resolve_library_id("csharp")
docs = get_library_docs(
    context7_compatible_library_id=csharp_id,
    topic="async-await-patterns",
    tokens=5000
)

# Entity Framework Core Documentation
ef_id = resolve_library_id("entity-framework-core")
ef_docs = get_library_docs(
    context7_compatible_library_id=ef_id,
    topic="querying-data",
    tokens=4000
)

# ASP.NET Core Documentation
aspnetcore_id = resolve_library_id("aspnetcore")
aspnetcore_docs = get_library_docs(
    context7_compatible_library_id=aspnetcore_id,
    topic="dependency-injection",
    tokens=3000
)

---

Related Skills & Resources

Language Integration:

• Skill("moai-context7-lang-integration"): Latest C#/.NET documentation

Quality & Testing:

• Skill("moai-foundation-testing"): C# testing best practices
• Skill("moai-foundation-trust"): TRUST 5 principles application

Security & Performance:

• Skill("moai-foundation-security"): Security patterns for .NET
• Skill("moai-essentials-debug"): C# debugging techniques

Official Resources:

• C# Documentation
• .NET Documentation
• Entity Framework Core
• ASP.NET Core
• xUnit Testing

---

Troubleshooting

Problem: NullReferenceException Solution: Use null-coalescing operator ?? and null-conditional ?.

Problem: Async deadlock Solution: Use .ConfigureAwait(false) in library code or ensure all calls are awaited

Problem: N+1 query problem Solution: Use .Include() for eager loading or projection with Select

Problem: Configuration not loading Solution: Ensure appsettings.json is in correct location and properly configured

---

Changelog

• v4.0.0 (2025-11-12): Enterprise upgrade - Progressive Disclosure structure, 83% content reduction, Context7 integration
• v3.0.0 (2025-03-15): C# 12 and .NET 8 patterns
• v2.0.0 (2025-01-10): Basic C# async/await patterns
• v1.0.0 (2024-12-01): Initial release

---

Resources

For working examples: See examples.md

For API reference: See reference.md

For advanced patterns: See full SKILL.md in documentation archive

---

Last updated: 2025-11-12 | Maintained by moai-adk team