I’ve begun coding in C# both as a gamedev hobbyist and at my new job.
I was a bit surprised that most C# project do not seem to adhere to common, explicitly stated rules or, at least, did not seem to enforce any via tooling.
Rider, my favorite editor, does not have a clear-cut convention to apply on all projects. Instead, it tries to automatically detect the current project’s code style and adhere to it, which does not help.
Existing code styles
Microsoft has some guidelines, but I found them a bit lacking.
They also have an .editorconfig file.
Roslyn code style’s summary:
- 4 spaces indentation
_camelCasefor private fields
varonly when usage is obvious
- use braces for
elseblocks except when they all fit on a single line
- new lines before braces
These rules are common in most C# projects I’ve read.
Google has a different code style, which tries to remove ambiguities from the official Microsoft guidelines.
Google code style’s summary:
- 2 spaces indentation
_camelCasefor every “privatish” field (
Iprefix for interfaces
varonly when usage is obvious
- Always use braces, even when optional
- NO new lines before braces
My personal preferences goes to google’s because I like braces for clarity.
And, perhaps more importantly, naming rules for
private stuff are not ambiguous
and simple to follow.
Tooling via editor config
Both Visual Studio and Rider support coding style via editorconfig:
I stumbled upon a great medium article by Jonathan Harrison that gave me a simple base to work on.
In summary, it allows you to define styles:
dotnet_naming_style.pascal_case_style.capitalization = pascal_case dotnet_naming_style.lower_camel_case_style.required_prefix = _ dotnet_naming_style.lower_camel_case_style.capitalization = camel_case
You can then use those styles in rules that have this form
<kind>.<name>.<prop>, where the
<name> is defined by you:
# privatish fields and properties: _camelCase # define 'private_fields' dotnet_naming_symbols.private_fields.applicable_kinds = field dotnet_naming_symbols.private_fields.applicable_accessibilities = private, protected, internal, protected_internal, private_protected # apply lower_camel_case_style to private fields dotnet_naming_rule.private_rule.symbols = private_fields dotnet_naming_rule.private_rule.style = lower_camel_case_style # Use PascalCase for public fields dotnet_naming_symbols.public_fields.applicable_kinds = field dotnet_naming_symbols.public_fields.applicable_accessibilities = public dotnet_naming_rule.pascal_case_for_public_fields.symbols = public_fields dotnet_naming_rule.pascal_case_for_public_fields.style = pascal_case_style dotnet_naming_rule.pascal_case_for_public_fields.severity = warning
See the documentation.
I created my personal editorconfig, trying to enforce google rules:
It’s probably not 100% correct, but I’ll try to update it as I go.
Tooling is crucial to have a homogenous code style in your projects.
I know that most C# devs will be horrified by my personal code style but this is irrelevant. What’s important is to have a code style and be consistent.
I now have an
.editorconfig file that I can drop in my projects. It is applied automatically
when I format my code.
This is enough for my side projects, but there are other tools that might be interesting to look at in the future:
There also seems to be a way to enforce code style in the dotnet build.
C# aficionados, I’m curious to hear your thoughts! Do you have a code style in your projects? Do you have tools to enforce it?