What are the naming conventions in C#? [closed]

Question

There are a few questions on this, but they all seemed to be targeting a specific part of the language;

• What are the most common naming conventions in C#? - Asking specifically about getters/setters.
• C# naming conventions for acronyms - Asking more specifically about short uppercase suffixes.

I'm just starting out in C# with a friend on a venture to create games for XBOX Live Arcade. I've developed a number of games using ActionScript 2 and 3 but want to start exploring more powerful languages and devices.

I want to ensure that I don't peeve people that I start working with (if I get to that) or even just people on here when I run into trouble and ask a question with seriously disturbing / "incorrect" naming of methods, etc.

I've found it confusing in the example code that I've seen because there seems to be from my current point of view some flaws. I doubt that a flawed naming convention would be used, so I realize that I'm just having trouble understanding.

As far as I can tell so far, there are these conventions:

• public Type SomeMethod()
• private Type SomeMethod() - no underscore or anything?
• public static Type SomeMethod()
• private static Type _SomeMethod() - this one just seems odd..
• public Type someProperty - switching it up to camel casing for properties?
• public static Type SomeProperty - and then going back to pascal casing for static..

In ActionScript 3, I have developed and strictly stick to these conventions:

• private var _someVar
• public var someVar
• private function _someMethod()
• public function someMethod()
• public static var SomeStaticVar
• public static function SomeStaticMethod()
• public const SOME_CONSTANT

Is there a complete list of naming conventions with reasoning behind each so that I can get my head around them? The reversal of syntax (i.e. public Type method() instead of AS3's public function method():Type) is throwing me out enough at the moment that I know I need to keep an eye on how I'm naming things, otherwise I'll forget and develop bad habits, which I'd rather nail and avoid now.

Answer 1

The two main Capitalizations are called camelCase and PascalCase.

The basic rules (with lots of variations) are

• Types use PascalCase
• properties and methods always use PascalCase
• public members (fields, consts) use PascalCase
• local variables use camelCase
• parameters use camelCase

And although the documentation states that "Internal and private fields are not covered by guidelines" there are some clear conventions:

• private fields use camelCase
• private fields that back a property prefix a _

Answer 2

There is the All-In-One Code Framework Coding Standards from Microsoft which contains a complete set of rules and guidelines. (also used to be available here)

This document describes the coding style guideline for native C++ and .NET (C# and VB.NET) programming used by the Microsoft All-In-One Code Framework project team.