Naming Conventions

Introduction

This topic outlines some basic naming conventions used when writing in the C# language. Like all conventions, they are not enforced by the compiler, but will ensure readability between developers.

For comprehensive .NET framework design guidelines, see docs.microsoft.com/dotnet/standard/design-guidelines.

Remarks

Choose easily readable identifier names

For example, a property named HorizontalAlignment is more readable in English than AlignmentHorizontal.

Favor readability over brevity

The property name CanScrollHorizontally is better than ScrollableX (an obscure reference to the X-axis).

Avoid using underscores, hyphens, or any other non-alphanumeric characters.

Do not use Hungarian notation

Hungarian notation is the practice of including a prefix in identifiers to encode some metadata about the parameter, such as the data type of the identifier, e.g. string strName.

Also, avoid using identifiers that conflict with keywords already used within C#.

Abbreviations and acronyms

In general, you should not use abbreviations or acronyms; these make your names less readable. Similarly, it is difficult to know when it is safe to assume that an acronym is widely recognized.

Capitalization conventions

The following terms describe different ways to case identifiers.

Pascal Casing

The first letter in the identifier and the first letter of each subsequent concatenated word are capitalized. You can use Pascal case for identifiers of three or more characters. For example: BackColor

Camel Casing

The first letter of an identifier is lowercase and the first letter of each subsequent concatenated word is capitalized. For example: backColor

Uppercase

All letters in the identifier are capitalized. For example: IO


Rules

When an identifier consists of multiple words, do not use separators, such as underscores ("_") or hyphens ("-"), between words. Instead, use casing to indicate the beginning of each word.

The following table summarizes the capitalization rules for identifiers and provides examples for the different types of identifiers:

IdentifierCaseExample
Local variableCamelcarName
ClassPascalAppDomain
Enumeration typePascalErrorLevel
Enumeration valuesPascalFatalError
EventPascalValueChanged
Exception classPascalWebException
Read-only static fieldPascalRedValue
InterfacePascalIDisposable
MethodPascalToString
NamespacePascalSystem.Drawing
ParameterCameltypeName
PropertyPascalBackColor

More information can be found on MSDN.

Enums

Use a singular name for most Enums

public enum Volume
{
   Low,
   Medium,
   High
}

Use a plural name for Enum types that are bit fields

[Flags]
public enum MyColors
{
    Yellow = 1,
    Green = 2,
    Red = 4,
    Blue = 8
}

Note: Always add the FlagsAttribute to a bit field Enum type.

Do not add 'enum' as a suffix

public enum VolumeEnum // Incorrect

Do not use the enum name in each entry

public enum Color
{
    ColorBlue, // Remove Color, unnecessary
    ColorGreen,
}

Exceptions

Add 'exception' as a suffix

Custom exception names should be suffixed with "-Exception".

Below are correctly named exceptions:

public class MyCustomException : Exception
public class FooException : Exception

Interfaces

Interfaces should be named with nouns or noun phrases, or adjectives that describe behaviour. For example IComponent uses a descriptive noun, ICustomAttributeProvider uses a noun phrase and IPersistable uses an adjective.

Interface names should be prefixed with the letter I, to indicate that the type is an interface, and Pascal case should be used.

Below are correctly named interfaces:

public interface IServiceProvider
public interface IFormatable

Namespaces

The general format for namespaces is:

<Company>.(<Product>|<Technology>)[.<Feature>][.<Subnamespace>].

Examples include:

Fabrikam.Math
Litware.Security

Prefixing namespace names with a company name prevents namespaces from different companies from having the same name.

Private fields

There are two common conventions for private fields: camelCase and _camelCaseWithLeadingUnderscore.

Camel case

public class Rational
{
    private readonly int numerator;
    private readonly int denominator;

    public Rational(int numerator, int denominator)
    {
        // "this" keyword is required to refer to the class-scope field
        this.numerator = numerator;
        this.denominator = denominator;
    }
}

Camel case with underscore

public class Rational
{
    private readonly int _numerator;
    private readonly int _denominator;

    public Rational(int numerator, int denominator)
    {
        // Names are unique, so "this" keyword is not required
        _numerator = numerator;
        _denominator = denominator;
    }
}