Format Method Parameters

Scope: What to Format

ALL projects:

All *.cs files EXCEPT auto-generated code. Exclude files with:

"generated", ".g.cs", ".designer.cs" in filename
AssemblyInfo.cs files
[GeneratedCode] or [GeneratedCodeAttribute]
<auto-generated> tags
"auto-generated" in headers
"This code was generated by a tool"

ONLY format parameter lists in DECLARATIONS:

Method declarations (public, private, protected, internal, static, async, virtual, override, abstract, etc.)
Constructor declarations
Local function declarations (functions defined inside methods)
Delegate declarations

DO NOT format parameter lists in INVOCATIONS or EXPRESSIONS:

Method calls/invocations (e.g., .Replace(...), .Substring(...))
Constructor invocations (e.g., new MyClass(...))
Ternary operators (e.g., condition ? value1 : value2)
Lambda expressions (e.g., (x, y) => x + y)
LINQ query expressions
Indexer property declarations (e.g., this[int x, int y])

Formatting Rules

Rule 1: Multiple Parameters

Break down all parameters if a method has more than 1 parameter, with each parameter on its own line.

Rule 2: Single Long Parameter

Break down a single parameter if the total line length (including indentation) exceeds 80 characters.

Examples

Declarations to Format

// No parameters - no break
public void MyMethod1()

// Single short parameter - no break
public void MyMethod2(int parameter1)

// Single parameter, total length > 80 chars - break
public void MyLooooooooooooooooooooooooooooooooooooooooooonMethod4(
    int parameter1)

// 2 parameters - break all
public void MyMethod5(
    int parameter1,
    int parameter2)

// 3+ parameters - break all
public void MyMethod6(
    int parameter1,
    int parameter2,
    int parameter3)

// Constructor with multiple parameters - break all
public MyClass(
    string name,
    int age,
    bool isActive)

// Local function with multiple parameters - break all
void LocalFunction(
    int param1,
    string param2)

// Delegate with multiple parameters - break all
public delegate void MyEventHandler(
    object sender,
    EventArgs e);

Invocations to Leave Unchanged

// Method invocations - DO NOT format
var result = assembly.GetBeautifiedName().Replace("Api", "API", StringComparison.Ordinal);
var name = someObject.SomeMethod(arg1, arg2, arg3);

// Constructor invocations - DO NOT format
var obj = new MyClass(param1, param2, param3);

// Ternary operators - DO NOT format
return condition ? value1 : value2;

// Lambda expressions - DO NOT format
var filtered = items.Where((item, index) => item.IsActive && index > 0);

// Indexer declarations - DO NOT format
public string this[int row, int column]

Execution Instructions

1. Scan for C# files

Find all .cs files in the repository.

2. Identify DECLARATIONS (not invocations)

Method declarations:

Lines starting with access modifiers: public, private, protected, internal
Lines with method modifiers: static, virtual, override, abstract, async, sealed
Pattern: [modifiers] [return-type] [method-name]([parameters])
Must have a return type (or void) before the method name
Usually followed by {, ;, or =>

Constructor declarations:

Pattern: [modifiers] [class-name]([parameters])
Class name matches the containing class
No return type before the name

Local function declarations:

Found inside method bodies
Pattern: [return-type] [function-name]([parameters])

Delegate declarations:

Pattern: [modifiers] delegate [return-type] [delegate-name]([parameters]);
Contains the delegate keyword

Key distinction from invocations:

Declarations have modifiers (public, private, static, etc.) OR are preceded by a type
Invocations follow a . (member access), are on the right side of =, or are arguments to other methods

3. Apply formatting rules

For each declaration found:

If 2+ parameters: break all parameters onto separate lines
If 1 parameter: break only if total line length > 80 characters
Ensure proper indentation (4 spaces per indentation level)
Place opening parenthesis ( on same line as method name
Place each parameter on its own line with proper indentation
Keep closing parenthesis ) on same line as last parameter

4. Process in batches

Work on files in manageable batches (e.g., 10-20 files at a time).

5. Verify after each batch

Run dotnet build to ensure no syntax errors.

6. Track progress

Use todo list to track which files have been processed.

7. Final verification

Run full test suite after all changes complete.

Guidelines

Preserve all code logic and comments
Maintain existing indentation style (spaces vs tabs)
Handle edge cases: attributes, generic types, default values, nullable types, ref/out/in parameters
Do not modify method bodies - only parameter declarations
Do not modify method invocations - only declarations
Leave ternary operators unchanged
Leave lambda expressions unchanged
Leave LINQ expressions unchanged
If uncertain whether something is a declaration or invocation, skip it and flag for manual review

format-params