Efficient_Edge5500 and other Reddit users exchange candid advice about achieving reliable and enforceable formatting/linting for .NET 4.7.1 projects in Visual Studio 2022, sharing practical tool recommendations and configuration insights.

Recommended Code Formatting and Linting Solutions for .NET 4.7.1 in VS2022

Summary: This community discussion addresses the recurring challenge of achieving enforceable and shareable code formatting for .NET Framework 4.7.1 projects in Visual Studio 2022. The main goals include enforcing rules like Pascal/camel case, whitespace, and style consistently across teams, ideally via git and on-build failures.

Original Question

The original poster asks for a universal, reliable solution to enforce formatting/styling rules in VS2022 for multiple .NET 4.7.1 csprojs. The tooling must:

  • Fail builds when rules are violated
  • Handle naming conventions, whitespace, etc.
  • Be easily shareable (preferably via git)
  • Actually work (not fragmented between Visual Studio settings and EditorConfig)

They note frustration with the limitations of .editorconfig and ask others for proven solutions.

Community Recommendations

1. CSharpier

  • CSharpier is mentioned as a formatter that guarantees completely formatted code after every run.
  • Some users mention subjective disagreements with CSharpier’s formatting choices, describing them as “non-standard” in some cases.

2. EditorConfig

  • Several developers report success using .editorconfig, pointing out the need to reload the solution for changes to take effect.
  • It’s highlighted that strict enforcement may not be possible for advanced rules, and that simple, standard rules work well. For more complex needs, Roslyn Analyzers are suggested.

3. StyleCop.Analyzers

  • The modern implementation (StyleCop.Analyzers on GitHub) is actively used for code style enforcement.
  • Configuration can be managed within .editorconfig, though documentation is reported as lacking.
  • The “Unstable” or pre-release package may be necessary to support modern C# versions, but it can trigger build warnings or other issues.

4. SonarAnalyzer.CSharp

  • Commonly added alongside StyleCop.Analyzers to provide additional static code analysis.
  • Users recommend tuning the included ruleset (.ruleset files) and increasing rule severity as needed.

5. CodeMaid

  • Previously popular for clean-up-on-save workflows but noted for stability problems and interference with refactoring in some cases.

6. General Tips

  • For advanced enforcement, combining analyzers and tuning .ruleset files is suggested.
  • Sharing all configuration files (EditorConfig, ruleset, etc.) in source control is crucial for team consistency.
  • Keep in mind that some tools only offer best-effort enforcement and cannot cover all style conventions out-of-the-box.

Conclusion

Enforcing code formatting and linting across a .NET team in VS2022 typically involves a combination of:

  • Configuration via .editorconfig (with solution reloads after changes)
  • Static analysis using StyleCop.Analyzers and SonarAnalyzer.CSharp
  • Optional formatters like CSharpier (with consideration for its formatting choices)
  • Maintaining shared configuration (via git) to keep rules consistent for the team

For strict build enforcement, focus on analyzers and ruleset configurations that cause build failures on violations. Adjust for language version and tool compatibility as needed.

Additional Resources

Share Your Experience

If your team uses other analyzers or has found a workflow that handles advanced style scenarios, this thread welcomes your suggestions.

This post appeared first on “Reddit CSharp”. Read the entire article here