“ANY FOOL CAN WRITE CODE THAT A COMPUTER CAN UNDERSTAND. GOOD PROGRAMMERS WRITE CODE THAT HUMANS CAN UNDERSTAND.”

Principles to follow for a clean C# style guide

The YAGNI principle

C# Code Style 🏊

// EXAMPLE: public and private variables
public float DamageMultiplier = 1.5f;
public float MaxHealth;
public bool IsInvincible;
private bool _isDead;
private float _currentHealth;
// parameters
public void InflictDamage(float damage, bool isSpecialDamage)
{
    // local variable
    int totalDamage = damage;
    // local variable versus public member variable
    if (isSpecialDamage)
    {
       totalDamage *= DamageMultiplier;
}
    // local variable versus private member variable
    if (totalDamage > _currentHealth)
{
/// ...
} 
}

• Avoid redundant names: If your class is called Player, you don’t need to create member variables called PlayerScore or PlayerTarget. Trim them down to Score or Target .
• Prefix Booleans with a verb: These variables indicate a true or false value. Often they are the answer to a question, such as – is the player running? Is the game over? Prefix them with a verb to make their meaning more apparent. Often this is paired with a description or condition, e .g ., isDead, isWalking, hasDamageMultiplier, etc .

Interfaces

// EXAMPLE: Interfaces
public interface IKillable
{
    void Kill();
}
public interface IDamageable<T>
{
    void Damage(T damageTaken);
}

Methods 🚀

• Start the name with a verb: Add context if necessary . e .g .,

GetDirection, FindTarget, etc .

• Use camel case for parameters: Format parameters passed into the

method like local variables.

• Methods returning bool should ask questions: Much like Boolean variables themselves, prefix methods with a verb if they return a true-false condition. This phrases them in the form of a question, e .g IsGameOver, HasStartedTurn .

// EXAMPLE: Methods start with a verb
public void SetInitialPosition(float x, float y, float z)
{
    transform.position = new Vector3(x, y, z);
}
// EXAMPLE: Methods ask a question when they return bool
public bool IsNewPosition(Vector3 currentPosition)
{
    return (transform.position == newPosition);
}

Events and event handlers 💫

1. Name the event with a verb phrase: Use present or past participle for events "before" or "after" (e.g., "OpeningDoor" or "DoorOpened").
2. Use System.Action delegate for events: Action<T> delegate can handle events with 0 to 16 input parameters and a void return type, saving code.
3. Prefix event-raising method (in the subject) with "On": The subject that invokes the event should have a method prefixed with "On" (e.g., "OnOpeningDoor" or "OnDoorOpened").
4. Prefix event-handling method (in the observer) with the subject's name and underscore (_): If the subject is "GameEvents," the observers can have a method called "GameEvents_OpeningDoor" or "GameEvents_DoorOpened."
5. Create custom EventArgs only as necessary: Create a new type of EventArgs to pass custom data to your event, either inherited from System.EventArgs or from a custom struct.

Using Properties in Unity C#

1. Use expression-bodied properties for single-line read-only properties: This returns the private backing field. Example:

public class PlayerHealth
{
    private int maxHealth;
    public int MaxHealth => maxHealth;
}

1. Use the { get; set; } syntax for all other cases: If you want to expose a public property without specifying a backing field, use the Auto-Implemented Property. Example:

public class PlayerHealth
{
    private int _maxHealth;
    public int MaxHealth
    {
        get => _maxHealth;
        set => _maxHealth = value;
    }
}

1. Control access with private setters: Make the setter private if you don't want to give write access.
2. Align closing braces: For multi-line code blocks, align the closing brace with the opening brace.

Class Organization in Unity

Naming Conventions 🤐

1. Folders:
• Use PascalCase (capitalize the first letter of each word).
• Keep names short and descriptive.
• Avoid spaces and special characters.
• Group related assets in subfolders.

Examples: Scripts, Materials, Prefabs, Textures, Audio.

2. Scripts:
• Use PascalCase for file names and class names.
• Make the file name and class name the same.
• Keep names descriptive and related to the script's purpose.

Examples: PlayerController, EnemySpawner, ScoreManager.

3. GameObjects in the scene:
• Use camelCase (capitalize the first letter of each word except the first).
• Prefix with a category or type for easy identification.
• Keep names short and descriptive.
• Avoid spaces and special characters.

Examples: playerCharacter, enemySpawner, uiCanvas, mainCamera.

4. Additional tips:
• Variables and Functions: Use camelCase for variable and Pascal Case for function names. Keep them descriptive and related to their purpose.

Examples: playerSpeed, enemyHealth, MovePlayer, SpawnEnemy.

• Constants: Use PascalCase with a 'k' prefix to denote constants.

Examples: kMaxHealth, kSpeedMultiplier.

• Namespaces: Use PascalCase for namespaces, and keep them short and related to the specific functionality or module.

Examples: Audio, InventorySystem, UI.

🎊 Conclusion

Resources

1. Create a C# style guide: Write cleaner code that scales → Unity Guide
2. Common C# Coding Conventions → Microsoft C#.
3. C# at Google Style Guide → Google Style Guide

✍️ Author

You may also like 💙

Mastering Scriptable Objects in Unity: A Complete Guide

🛩️

Mastering Scriptable Objects in Unity: A Complete Guide

DeveloperTips

Unity Serialization System

🔁

Unity Serialization System

DeveloperTutorial