Results for “c#”

Run small C# apps without creating a project, using the .NET CLI, its command-line tool. Use it to test language features, explore APIs, or prototype utilities with helper files and NuGet packages.

• Trying C# language features or APIs
• Prototyping logic before project integration
• Building a small utility with helper files

Match C# and .NET tasks to the appropriate specialist skill using the request and project evidence. Invoke available specialists, explain how to obtain missing plugins, and complete suitable tasks with standard tooling when possible.

• Choosing a specialist for a C# or .NET task
• Finding the plugin needed for a missing specialist
• Restoring discovery of already installed skills

Write and review C# and .NET tests using xUnit examples. Covers unit tests, mocks that replace dependencies, API and database integration tests, reusable test data, and project organization to check behavior and outcomes.

• Adding tests for C# services
• Testing ASP.NET Core APIs
• Checking database persistence

Scan C# code for dependencies on clocks, files, environment settings, and other resources that make tests difficult. Get source locations, consistent counts, and suggested abstractions, interfaces or providers that let tests control those dependencies.

• Assessing testability before adding unit tests
• Finding hidden dependencies in legacy C# code
• Prioritizing dependencies to replace

Write, review, and refactor C# and .NET code using practical conventions for asynchronous work, configuration, and dependency injection—passing services into classes. Includes examples for data access and APIs to support maintainable applications.

• Reviewing C# implementation conventions
• Improving asynchronous code and cancellation handling
• Organizing service dependencies and configuration

Build cryptocurrency exchange integrations in C# and .NET with CCXT. Get guidance on setup, market data, orders, authentication, and error handling, using REST for individual requests and WebSocket connections for live price and order book updates.

• Adding cryptocurrency prices to a C# application
• Implementing order placement and cancellation
• Monitoring live prices and order books

Analyze compiled .NET and C# programs by identifying managed files, removing obfuscation, inspecting intermediate instructions, and debugging runtime behavior. Save extracted configuration and code changes as evidence for further review.

• Inspect compiled .NET program behavior
• Analyze obfuscated C# programs
• Extract malware configuration and communication destinations

Build and troubleshoot C#/.NET MCP servers that expose tools and information to AI agents. Guidance targets the official 2.x SDK and covers transport setup, authentication, interactive features, basic clients, and migration issues caused by changed defaults.

• Build a C#/.NET MCP server
• Add tools, prompts, and resources
• Diagnose STDIO and HTTP connection errors

Build and review C#/.NET APIs and business backends using concrete implementation patterns. Cover asynchronous operations, service dependencies, database access, configuration, caching, and tests to structure application code and examine quality and performance issues.

• Designing a new .NET Web API
• Reviewing asynchronous C# code
• Improving database access and caching

Get C# examples for timezone conversion, location lookup, and scheduling in .NET applications. The skill explains Windows and IANA timezone identifiers, daylight saving changes, and suitable libraries for different platforms and scheduling needs.

• Find timezone identifiers for cities and addresses
• Convert between UTC and local time in C#
• Handle timezones across Windows and Linux

Introduce nullable reference types into an existing C# project, making explicit which references may be null. Plan a staged migration, resolve compiler warnings, and clarify public API annotations while preserving runtime behavior.

• Adopting nullable reference types in an existing C# project
• Migrating a large codebase file by file
• Clarifying nullability in public APIs

Manage s&box game projects through text commands. Edit scenes and reusable object templates, generate C# components, configure controls and translations, and inspect asset references to find unused files or validate project consistency.

• Create scenes and reusable object templates
• Generate C# components and UI scaffolds
• Configure controls, collisions, and translations

Migrate the database access layer of a .NET/C# application from Oracle to PostgreSQL with Npgsql. Update packages, connection settings, parameter types, SQL, and stored procedure calls, then build the copied project and track completed migration tasks.

• Migrate C# database access from Oracle to PostgreSQL
• Replace Oracle packages and connection settings
• Review parameter types and stored procedure calls

Review and improve .NET/C# code against project conventions. Cover public API documentation, dependency injection for supplying services to classes, asynchronous operations, tests, configuration, logging, and input validation, including guidance for Semantic Kernel integrations.

• Review C# code against project conventions
• Improve XML documentation for public APIs
• Review asynchronous operations and dependency injection

Review C#/.NET code for design patterns, separation of responsibilities, and common implementation issues. Receive actionable recommendations covering maintainability, testing, performance, and security without changing the code.

• Review design patterns in C#/.NET code
• Check separation of responsibilities before refactoring
• Identify dependencies that make testing difficult

Refactor C#/.NET code through renaming, extraction, consolidation, and other structural changes while preserving behavior. Check compatibility beyond code references, including public APIs and serialized names, then validate with builds and relevant tests.

• Rename C# members and update their references
• Extract shared logic from duplicate code
• Reorganize code while preserving public API compatibility

Make specific C# behavior testable by adding a minimal way to replace time, randomness, or other external dependencies. Preserve public APIs and production behavior, then run repeatable tests without real file access or waiting.

• Testing deadlines and delays with controlled time
• Testing file operations without touching real files
• Testing random or environment-dependent behavior

Review C#/.NET code for about 50 inefficient API usage patterns across asynchronous work, memory, strings, collections, and I/O. Get exact occurrence counts, prioritized findings, and concrete fixes, with attention to frequently executed code.

• Reviewing frequently executed C#/.NET code
• Finding unnecessary memory allocations
• Checking known performance pitfalls before release

Write and improve C# unit tests with MSTest 3.x/4.x. Covers assertions that check expected results, tests with multiple input sets, asynchronous setup, cleanup, and test organization, with guidance on APIs that differ between versions.

• Create a C# unit test project
• Test multiple input sets with DataRow or DynamicData
• Update exception checks to modern assertion APIs

Write focused C# unit tests with XUnit, including tests that run against multiple input datasets. Apply consistent naming, setup, assertions, shared fixtures, and mock dependencies to keep tests readable, independent, and organized.

• Set up an XUnit test project for C#
• Test multiple input cases with Theory and data attributes
• Check exceptions and isolate dependencies with mocks

Compare C# Web API source code with its TypeScript or JavaScript clients to find mismatched data fields, required inputs, and response handling. Receive an audit report showing client impact, severity, and confidence in each match.

• Check client impact before merging a DTO or controller change
• Audit API compatibility before a release
• Find stale request fields and missing response fields

Build and improve Windows desktop apps with C#, WinUI 3, and the Windows App SDK. Guidance covers development setup, native interface design, implementation, troubleshooting, packaging choices, and verification through both builds and actual app launches.

• Checking and preparing a WinUI development environment
• Creating a new Windows desktop app
• Improving navigation, themes, and adaptive layouts

Build C# applications with .NET 8+, including ASP.NET Core APIs and Blazor interfaces. Get models, endpoints, services, and configuration, with guidance on database access, asynchronous operations, cancellation, authentication, performance tuning, and tests.

• Build a REST API with ASP.NET Core
• Implement database access with Entity Framework Core
• Create Blazor components and manage application state

Use C#/.NET in Godot 4.7: partial classes extending nodes, the PascalCase lifecycle (_Ready/_Process/_PhysicsProcess), [Export] fields, [Signal] delegates as C# events, type-safe node lookup, and calling between C# and GDScript. Use when writing Godot game code in C# (.cs files, .csproj), needing the Godot .NET build, converting GDScript patterns to C#, or wiring Godot signals as C# events.

The English summary is being prepared. Showing the original description.