Code Style Standards

Purpose

Consistent code style improves readability, reduces cognitive load, and helps prevent common coding mistakes. These standards ensure:

• Uniform code appearance across all projects
• Enhanced code maintainability
• Easier code reviews
• Reduced potential for bugs
• Better automated analysis and refactoring

Code Layout

File Organization

// 1. File header with copyright and license
// 2. Namespace imports (sorted and grouped)
using System;
using System.Collections.Generic;
using System.Linq;

using Microsoft.Extensions.Logging;

using YourCompany.Core.Interfaces;
using YourCompany.Core.Models;

// 3. Namespace declaration
namespace YourCompany.Feature
{
    // 4. Type declaration
    public class FeatureManager : IFeatureManager
    {
        // 5. Fields (private)
        private readonly ILogger<FeatureManager> _logger;
        
        // 6. Constructors
        public FeatureManager(ILogger<FeatureManager> logger)
        {
            _logger = logger;
        }
        
        // 7. Properties
        public bool IsEnabled { get; private set; }
        
        // 8. Public methods
        public void Enable()
        {
            IsEnabled = true;
        }
        
        // 9. Private methods
        private void LogStatus()
        {
            _logger.LogInformation("Feature status: {Status}", IsEnabled);
        }
    }
}

Indentation and Spacing

• Use 4 spaces for indentation, never tabs
• One empty line between methods
• One empty line between property groups
• No empty line after opening brace or before closing brace
• Empty line before control flow statements (if, while, for, etc.)

// Good
public class Example
{
    private readonly string _name;
    private readonly int _count;

    public string Name => _name;
    public int Count => _count;

    public void ProcessItem()
    {
        if (_count > 0)
        {
            // Processing logic
        }

        foreach (var item in items)
        {
            // Loop logic
        }
    }
}

// Bad
public class Example {
    private readonly string _name;    private readonly int _count;
    public string Name=>_name;
    public int Count=>_count;
    public void ProcessItem() {
        if(_count>0){
            // Processing logic
        }
        foreach(var item in items){
            // Loop logic
        }
    }
}

Formatting Rules

Line Breaks and Wrapping

• Maximum line length: 120 characters
• Break method chains after the dot
• Align parameters when breaking method calls
• Break before binary operators

// Good
var result = dataContext
    .Users
    .Where(u => u.IsActive)
    .Select(u => new UserDto
    {
        Id = u.Id,
        Name = u.Name
    })
    .ToList();

// Bad
var result = dataContext.Users.Where(u => u.IsActive).Select(u => new UserDto { Id = u.Id, Name = u.Name }).ToList();

Parentheses and Braces

• Always use braces for control statements
• Opening brace on the same line
• Closing brace on its own line
• Space before opening brace

// Good
if (condition)
{
    DoSomething();
}

// Bad
if (condition) DoSomething();
if (condition)
    DoSomething();

Language Features

Var Usage

• Use var when type is obvious from the right side
• Use explicit type when type is not obvious
• Always use explicit type for numeric values

// Good
var users = new List<User>();
var dictionary = new Dictionary<string, int>();
int count = GetCount();

// Bad
var count = GetCount();
List<User> users = new List<User>();

Expression-Bodied Members

• Use for simple, single-line members
• Avoid for complex logic
• Prefer for read-only properties

// Good
public string FullName => $"{FirstName} {LastName}";
public override string ToString() => FullName;

// Bad
public string FullName => 
    FirstName.Length > 0 
        ? $"{FirstName} {LastName}" 
        : LastName;

Null Checking

• Use null-conditional operator (?.) when appropriate
• Use null-coalescing operator (??) for defaults
• Implement null checks at method entry points

// Good
public void ProcessUser(User user)
{
    ArgumentNullException.ThrowIfNull(user);
    var name = user.Profile?.Name ?? "Unknown";
}

// Bad
public void ProcessUser(User user)
{
    var name = user != null ? user.Profile != null ? user.Profile.Name : "Unknown" : "Unknown";
}

Modern C# Features

Pattern Matching

• Use pattern matching for type checks
• Prefer switch expressions for simple mappings
• Use property patterns where applicable

// Good
var result = value switch
{
    string s => ProcessString(s),
    int n => ProcessNumber(n),
    null => ProcessNull(),
    _ => ProcessDefault()
};

// Bad
string result;
if (value is string)
    result = ProcessString((string)value);
else if (value is int)
    result = ProcessNumber((int)value);

Record Types

• Use records for immutable data models
• Prefer positional records for simple DTOs
• Use record classes when inheritance is needed

// Good
public record User(string Name, string Email);
public record class AdminUser(string Name, string Email, string[] Permissions) : User(Name, Email);

// Bad
public class User
{
    public string Name { get; init; }
    public string Email { get; init; }
}

Commenting Style

Code Comments

• Use // for single-line comments
• Use /* */ for multi-line comments
• Keep comments current with code
• Avoid obvious comments

// Good
// Retry operation with exponential backoff
private async Task<T> RetryOperationAsync<T>(Func<Task<T>> operation)

// Bad
// Get user
public User GetUser(int id)

Enforcement

Tools Configuration

.editorconfig

# Code style rules
csharp_style_var_for_built_in_types = false:error
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_var_elsewhere = false:suggestion

# Formatting rules
csharp_new_line_before_open_brace = all
csharp_space_after_keywords_in_control_flow_statements = true

IDE Settings

• Enable "Format on Save"
• Configure ReSharper/Visual Studio code cleanup
• Use StyleCop analyzers
• Enable .NET analyzers

Best Practices

Do's

• Keep methods small and focused
• Follow Single Responsibility Principle
• Use meaningful names
• Always add XML comments for public and private members
• Use consistent formatting

Don'ts

• Don't repeat code, keep it DRY
• Don't ignore compiler warnings
• Don't use region directives
• Don't use magic numbers
• Don't leave commented-out code

Additional Resources

• Microsoft C# Coding Conventions
• .NET Runtime Coding Guidelines