C# Coding Style

Braces

namespace Bitsquid
{
public class Resource
{
public string AbsolutePath
{
get { return _absolute_path; }
set { _absolute_path = value; }
}

public IEnumerable<string> GetDependencyPaths()
{
var paths = new List<string>();

foreach (var dependency in Dependencies)
{
var path = dependency.AbsolutePath;
paths.Add(path);
}

return paths;
}
}
}

Omitting braces

while (test)
{
// Simple test, single statement.
if (another_test)
DoSomething();

// Always add an empty line after such a statement.
DoAnotherThing();
}
But not in these situations:
// BAD - Multiple simple statements make scope unclear.while (test)
if (another_test)
DoSomething();

// BAD - All sections of a complex branch should have braces.if (test)
DoSomething();
else
{
DoSomethingElse();
}

Naming

Name namespaces LikeThis

Name classes and structs LikeThis

{
...
}
public class MeshResource : Resource
{
...
}

Name interfaces ILikeThis

public interface IConnection
{
...
}

public interface IJsonSerializable
{
...
}

Name variables and method arguments like_this

Name member variables _like_this

public class Resource
{
private int _reference_count;
private bool _is_relative;
}

Name methods LikeThis()

private IEnumerable< string > GetExistingFilePaths()
{
return _absolute_paths.Where(File.Exists);
}

Name properties LikeThis

Boolean properties

private bool CanScrollHorizontally
{
get { return _can_scroll_horizontally; }
set { _can_scroll_horizontally = value; }
}

Name constants and enum entries LikeThis

Name enums and enum values LikeThis

public enum GeometryType
{
Box,
Sphere,
Capsule,
Mesh,
}

[Flags]
public enum FileAttributes
{
Read = 1,
Write = 2,
Execute = 4,
}

Indentation and Spacing

namespace Stingray.View.ValueConverters
{
public class NumericValueConverter : IValueConverter
{
...
}
}

Organization

Organize using statements

• Using statements should be placed at the top of the file.
• Using statements should not be indented.
• Using statements should be ordered alphabetically.
• Using statements referring to the System namespace are ordered before all other using statements.
• Using statements that define aliases are ordered after all other using statements.
• Using statements that are not required by the code inside the file should be removed.

Put state at the top of the class

public class Resource
{
// State
public string AbsolutePath { get; private set; }
private bool _is_relative;

public Resource(string path)
{
...
}
}

Initialize members in constructors

public class Resource
{
// State
public string AbsolutePath { get; private set; }
private bool _is_relative = true; // BAD! Do it in the constructor instead.

public Resource(string path)
{
AbsolutePath = path;
_is_relative = IsRelativePath(path);
}
}

Style Considerations

Modifier keywords

// BAD: Accessibility is unclear.class MyClass
{
string _name;
int _age;
}

// BETTER: Explicit accessibility makes it clearer.internal class MyClass
{
private string _name;
private int _age;
}

Modifier keyword order

Use var

// BAD: Explicit type declarations make the code "noisy" and harder to read.int index = 5;
string greeting = "Hello";
double height = 1.0;
int[] numbers = new int[] { 1, 2, 3 };
Dictionary< Guid, ReadOnlyCollection< Tuple< int, string > > > orders = new Dictionary< Guid, ReadOnlyCollection< Tuple< int, string > > >();

// BETTER: Using the var keyword stops us from having to repeat ourselves and makes the statements line up nicely.var index = 5;
var greeting = "Hello";
var height = 1.0;
var numbers = new[] { 1, 2, 3 };
var orders = new Dictionary< Guid, ReadOnlyCollection< Tuple < int, string > > >();

Use object initializers

// BAD: Create an object and poke at it.var james = new Employee();
james.Id = Guid.NewGuid();
james.Name = "James";
james.Manager = susan;

// BETTER: The Employee is created and configured with a single statement.var james = new Employee { Id = Guid.NewGuid(), Name = "James", Manager = susan };
You can also use collection initializers to populate a collection with a single statement.

// BAD: Create a collection and poke at it.
var names = new List< string >();
names.Add("John");
names.Add("Paul");
names.Add("George");
names.Add("Ringo");

// BETTER: The list is created and populated with a single statement.var names = new List< string > { "John", "Paul", "George", "Ringo" };
Collection initializers can be used to populate any collection that implements the IEnumerable interface, including Dictionary< TKey, TValue >. The syntax for initializing a dictionary is slightly different:
var number_words = new Dictionary< int, string > {
{ 0, "zero" },
{ 1, "one" },
{ 2, "two" },
...
{ 9, "nine" }
}