C#/.NET Compiler + AIO Toolkit

Automatically organizes C# using statements in alphabetical order with configurable namespace grouping and duplicate removal. The extension parses the using block at the top of C# files, applies deterministic sorting rules based on the `dotnetaio.sort.usings.order` configuration (defaulting to System namespaces first), and optionally inserts blank lines between namespace groups when `dotnetaio.sort.usings.splitGroups` is enabled. This operates as a static text transformation without AST parsing, making it fast but limited to simple reordering.

Scans C# source files line-by-line and corrects indentation levels based on code structure (blocks, nested scopes, preprocessor directives). The extension applies configurable rules via `dotnetaio.style.indent.*` settings to determine whether to indent preprocessor directives, region blocks, and switch-case labels. It operates as a regex or line-based transformation (not AST-aware), making it fast but unable to handle complex nesting or mixed-indentation scenarios accurately. Wrapped lines are processed with special handling to preserve logical continuation.

The extension claims to provide '.NET Compilation Support,' but the architectural analysis explicitly states 'This extension is not a compiler itself,' creating ambiguity about what compilation capability actually exists. The documentation does not specify whether the extension invokes an external compiler, provides compilation diagnostics, or merely claims compatibility with .NET projects. No configuration for targeting specific .NET versions or SDKs is documented, suggesting this capability may be aspirational or limited to project file recognition.

Transforms opening brace placement in C# code between K&R style (opening brace on same line as declaration) and Allman style (opening brace on new line). Controlled by `dotnetaio.style.braces.onSameLine` (true = K&R, false = Allman) and `dotnetaio.style.braces.allowInlines` (permits single-line expressions like `if (x) { return; }`). The extension uses line-based pattern matching to detect brace positions and relocate them, without full AST parsing, making it fast but potentially fragile on complex or malformed code.

Removes excessive blank lines from C# source files and normalizes spacing to a configurable maximum (controlled by `dotnetaio.style.newline.*` settings, though specific setting name is UNKNOWN). The extension scans the file for consecutive blank lines and collapses them to the configured limit, improving code density and readability. This is a simple line-based transformation that does not understand code structure, making it fast but unable to preserve intentional spacing around logical sections.

Allows selective indentation of C# preprocessor directives (#if, #endif, #define, etc.) based on the `dotnetaio.style.indent.preprocessorIgnored` setting (default: true, meaning preprocessor directives are NOT indented). When disabled, the extension applies indentation rules to preprocessor lines as if they were regular code, improving visual alignment with surrounding blocks. This is a line-based filter applied during indentation normalization, not a separate pass.

Allows selective indentation of C# region and endregion directives (#region, #endregion) based on the `dotnetaio.style.indent.regionIgnored` setting (default: false, meaning regions ARE indented). When enabled, region directives are indented to match surrounding code blocks; when disabled, they remain at column 0. This is a line-based filter applied during indentation normalization, similar to preprocessor directive handling.

Allows selective indentation of switch-case labels (case and default keywords) based on the `dotnetaio.style.indent.switchCaseIgnored` setting (default: false, meaning case labels ARE indented). When enabled, case and default labels are indented to align with the switch statement body; when disabled, they remain at the same indentation level as the switch keyword. This is a line-based filter applied during indentation normalization, targeting a specific C# language construct.

Enables formatting of multiple C# files in a folder or project by right-clicking a folder in the VS Code Explorer and selecting a batch-format option. The extension applies all enabled formatting rules (using sorting, indentation, brace style, etc.) to every .cs file in the selected folder and its subfolders. This is a convenience wrapper around the single-file formatting logic, executed sequentially on each file without parallelization or progress reporting.

Integrates with VS Code's standard 'Format Document' command (typically Shift+Alt+F on Windows/Linux, Shift+Option+F on macOS) to apply all enabled formatting rules to the currently-active C# file. The extension registers itself as a formatter provider in the VS Code formatting pipeline, allowing it to be invoked on-demand or automatically (if `editor.formatOnSave` is enabled, though explicit compatibility is UNKNOWN). Formatting is applied in-place to the active editor buffer without creating backups or requiring file saves.

The extension claims to detect errors in C# code and apply automatic fixes 'on the fly,' but the documentation does not specify what types of errors are detected, how detection works, or what fixes are applied. This capability is mentioned in the marketplace description but lacks implementation details. It may refer to simple pattern-based fixes (e.g., missing semicolons) or more sophisticated analysis, but without architectural documentation, the actual scope and mechanism are UNKNOWN.