Coding Guideline for Unity C#

As a programmer, it is very important to follow a coding standard and make sure others can read and easily understand his code. While there's not majority guideline of coding standard in Unity and C#, you can somehow write whatever you like, but in this article, I'm going to show you our style and format guideline within the company. We have tried to adopt different styles throughout these years and came out the one we feel most comfortable.

Our 3 golden rules to forms our style standard:
1. Follow Unity's style in Scripting Reference
2. The rest follow Microsoft's C# Coding Conventions
3. Minor tweak where we believe that can make the code clearer

Folder Structure

All similar files should be grouped in the root folders:

Assets
  Animations       Animation clips
  Editor           Editor specified scripts, prefabs, etc
  Fonts            Fonts used in game
  Materials        Texture materials
  Prefabs          In-game prefabs
  Resources        Unity resources assets
  Scenes           Scenes
  Scripts          Code scripts, grouped in sub-folders
  Sounds           Musics, sounds
  SweatyChair      Company folder that share across projects
    (ModuleName1)  Module name, e.g. DailyLogin
      (Scripts)    Scripts within the module
      (Prefabs)    Prefabs within the module
      ...          Other assets grouped in folders
    ...            Other modules
  Textures         Image textures
    UI             Texture used for UI
    Icons          App icons

File Naming

File naming is simple, always use Pascal Case except for images:

Scripts Naming

While each script has its unique purpose and use cases, we follow these naming rules and so we can still roughly know what the script is for by simply reading the filenames:

Variable Naming

Similar to file naming, variable naming allow us to know what the variable is for without reading though all code:

Functions Naming

Member Properties

If a function has no input, use member property (aka get/set property) instead, in PacelCase as well:
bool IsRewarded() { }
to
bool IsRewarded {get { return …} }
Or even in a shortened form as
bool IsRewarded => ...;

Also, use member properties where a variable can only set internally but can be accessed publicly:
public int Id { get; private set; }
public Sprite IconSprite { get; private set; }

Variables / Functions orders

Having a consistent order can greatly save our time on looking for a specific variable or function:

MyCalss : Monobehavior
{
  // Constant variables
  public const int CONST_1;
  private const string CONST_2;

  // Static variables
  public static int static1;
  private static string _static2;
  
  // Editor-assigned variables
  [SerializeField] public Image maskImage;
  [SerializeField] private MyClass _anotherComponent;

  // Other varaibles
  public int primitiveVariables1;
  private string _primitiveVariable2;

  // Properties
  public int Property1 {get; set;}
  private string _roperty2 {get; set;}

  // Unity functions
  Awake()
  OnEnable()
  Start()
  Update()
  FixedUpdate()

  // Other custom functions
  Init()
  ...
  Reset()

  // Unity functions
  OnDisable()
  OnDestroy()

#region UNITY_EDITOR
  // Eebug functions that only runs in Editor
  [ContextMenu("...")]
  private void DebugFunction1()
  [MenuItem("Debug/...")]
  private static void DebugFunction2()
#endregion
}

You can also group valuables and functions in a region in large scripts (but not too large enough to be split into another script):

#region Timer
  private const int RESET_SECONDS = 180;
  private float _secondsLeft;
  public float canResetTime => _secondsLeft < 0;
  public void ResetTime()
  {
    _secondsLeft = RESET_SECONDS;
  }
#endregion Timer
... // Other regions

Code Formatting

We use K&R style which is already preset in Mac Visual Studio:

While there's not K&R in Windows (Why, Microsoft?), just a little bit effort to manually set few ticks:

Brackets and Newlines

For single-line conditional statements we do not need any brackets:

if (1 == 1)
  DoSomethingFancy();
if (1 == 1) return true;
if (1 == 1) {
  FirstThing();
  LastThing();
}

Comments

Single line comments should include a space after the slashes:
// Notice the space after the two slashes
Temporarily commenting out code should not include a space after the slashes, to be differentiated from the normal comment:
//noSpace.Code();
TODO comments should include the space after the slashes and then 2 spaces after the colon following the TODO
// TODO: Notice the space after the slashes and the 2 spaces after the colon of todo

That's all. This may go bigger when you adopt more latest .Net syntax. There are also a few other good guidelines if you want to read more. Free feel to follow this style if you think it's reasonable and helpful, so we may create a better game dev world where code is clean and please to read. 😀

(Originally posted in Richard's Blog)