Why Access Singleton Class via Instance in Unity

Why Access Singleton Class via Instance in Unity

In C# or Unity, when creating a Singleton class, we typically choose between two approaches:

  • One is to expose the Instance publicly so you access it via Manager.Instance.SomeFunction().
  • The other is to hide the Instance and wrap the variable or function in a static property, so you access it directly with Manager.SomeFunction().

Both methods work in practice, but in the long term, using the Instance explicitly is much better.

Exposing the Instance

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }

    public void StartGame() { }
}

Usage:

GameManager.Instance.StartGame();

You always access it via the Instance.

Hiding the Instance and Wrapping in Static

public class GameData : MonoBehaviour
{
    private static GameData _instance;

    public static bool IsGameStarted
    {
        get { return _instance.isGameStarted; }
    }

    private bool isGameStarted;
}

Usage:

if (GameData.IsGameStarted)
{
    // process
}

It looks like you are accessing it statically.

Why Not Just Use Static?

Honestly, it's possible. Many codes use this static wrapping approach.

However, over time, problems start to arise:

It Looks Static but Internally Uses Instance

Even if you wrap the property in static, inside, it still references the _instance.

This _instance depends on Unity objects. If, during scene transitions or in cases where you manually call Destroy() or Play/Stop in the editor, the object is destroyed, Instance becomes null, and trying to access it as if it's static will lead to a crash.

Unity's Lifecycle Doesn't Match Static Wrapping

Unity dynamically creates and destroys objects, but static variables stay in memory throughout the program.

If you're still holding onto a static pointer for a destroyed object, it will cause runtime errors and even memory leaks.

It Doesn't Align with Singleton Philosophy

Singleton is a pattern for managing "one living object." The object needs to exist, and we should be able to ensure it's alive when needed and possibly destroyed at the right time.

Static wrapping ignores the lifecycle of the object and messes with the core design intention of a Singleton.

Difference from Static-Only Classes

Here's a key distinction.

For example, Unity's Mathf class is a collection of static functions that don't need to hold state:

float clamped = Mathf.Clamp(value, min, max);

Mathf doesn't store any values. It doesn't remember past calculations. It simply calculates and returns the result based on the input parameters.

Such classes don't need an object instance, so static is the correct approach.

On the other hand, GameManager or GameData classes:

  • Need to store game state
  • Manage events
  • Behave like living objects

So, handling living objects as static-wrapped properties is fundamentally different from static-only classes like Mathf.

Summary

Although it's easier to use static wrapping, you should always access Singleton classes through Instance.

Doing so ensures that you are always conscious of whether the object is alive, allows you to naturally synchronize with Unity's lifecycle, and maintains the integrity of the "living object" concept that Singleton is meant to manage.

Classes like GameManager or data storage managers should expose their Instance to reveal the design intention clearly.

In the end, accessing through Instance isn't just about dealing with the inconvenience of extra typing—it's about ensuring code consistency and system stability.

Popular posts from this blog

Understanding Arrays as Reference Types in C#

Image
Arrays as Reference Types In programming, it's important to understand the behavior of arrays. In most programming languages including C#, arrays are treated as reference types. This article will explore what that means and how to use that knowledge effectively. Value Types vs Reference Types In C#, data types are categorized into two main types: Value types : Store actual values directly. Examples : int , float , bool , struct Reference types : Store memory addresses instead of the actual values. Examples: class , string , array , delegate Arrays, like classes, are reference types. When you assign one array variable to another, you're copying the reference, not the actual data. Example: Arrays as Reference Types using System; class Program { static void Main() { int[] array1 = { 1, 2, 3 }; int[] array2 = array1; // Copy reference array2[0] = 100; Console.WriteLine(array1[0]); // Out...
Read more

Setting Up a Basic Follow Camera with Cinemachine 3.x

Image
Setting Up a Basic Follow Camera with Cinemachine 3.x Cinemachine has been significantly upgraded in version 3.x, introducing new concepts, improved terminology, and a refined workflow. In this post, we’ll go through how to set up a simple follow camera using the latest version. For more advanced examples, be sure to check out the sample scenes provided in the Cinemachine package—they’re very helpful for understanding the system. Install the Cinemachine Package Start by downloading and importing the Cinemachine package from the Unity Package Manager. Check the Main Camera After installation, you'll notice that the Main Camera now has a Cinemachine Brain component attached. Make sure the Live Camera field shows the name of your Cinemachine Camera. Create a Cinemachine Camera In the Hierarchy window, right-click and go to Cinemachine > Cinemachine Camera to create a new virtual camera. Set the Tracking Targe...
Read more

How to Initialize Struct – C# Struct Initialization Guide

Image
How to Initialize Struct – C# Struct Initialization Guide In C#, there are multiple ways to declare and initialize structs. While using just one method is often enough, it's common to encounter different initialization styles in real-world code. This guide summarizes the most common approaches, including how to handle struct arrays and lists. Struct Declaration struct Item { public string name; public int price; public string desc; } 1. Declare First, Assign Later This is the most straightforward method. Declare the struct first, then assign values to its fields one by one. Item item; item.name = "Fireball"; item.price = 100; item.desc = "Deals fire damage to the enemy."; Note: Structs are value types, so you can declare them without new . However, you must initialize all fields before use, or you'll get a compile-time error. 2. Use new and Assign Fields Item item = new Item(); item.name = "Fir...
Read more