Skip to main content

5.4 - Constructors

When you create a new object in C#, you need a way to initialize its state. This is where constructors come in. Constructors are special methods that are called when an object is created, allowing you to set initial values and perform any setup operations needed for the object to be in a valid state.

What is a Constructor?​

A constructor is a special method that:

  • Has the same name as the class
  • Does not have a return type (not even void)
  • Is called automatically when an object is created using the new keyword

The primary purpose of a constructor is to initialize the new object's state, ensuring it starts with valid and meaningful values.

Default Constructor​

If you don't define any constructors in your class, C# provides a default (parameterless) constructor that initializes all fields to their default values:

  • Numeric types: 0
  • Boolean: false
  • Reference types: null
public class Player
{
    // Fields
    public string name;
    public int health;
    public bool isAlive;
    
    // No constructor defined, so C# provides a default one
}

// Usage
Player player = new Player();
Console.WriteLine($"Name: {player.name}");     // Output: Name: 
Console.WriteLine($"Health: {player.health}"); // Output: Health: 0
Console.WriteLine($"Alive: {player.isAlive}"); // Output: Alive: False

However, once you define any constructor, the default constructor is no longer provided automatically. If you still want a parameterless constructor, you need to define it explicitly.

Defining Your Own Constructors​

Parameterless Constructor​

You can define your own parameterless constructor to initialize fields with specific values:

public class Player
{
    public string name;
    public int health;
    public bool isAlive;
    
    // Explicit parameterless constructor
    public Player()
    {
        name = "Unknown";
        health = 100;
        isAlive = true;
    }
}

// Usage
Player player = new Player();
Console.WriteLine($"Name: {player.name}");     // Output: Name: Unknown
Console.WriteLine($"Health: {player.health}"); // Output: Health: 100
Console.WriteLine($"Alive: {player.isAlive}"); // Output: Alive: True

Parameterized Constructor​

You can also define constructors that accept parameters, allowing the caller to specify initial values:

public class Player
{
    public string name;
    public int health;
    public bool isAlive;
    
    // Parameterized constructor
    public Player(string playerName, int initialHealth)
    {
        name = playerName;
        health = initialHealth;
        isAlive = (health > 0);
    }
}

// Usage
Player hero = new Player("Hero", 100);
Console.WriteLine($"Name: {hero.name}");     // Output: Name: Hero
Console.WriteLine($"Health: {hero.health}"); // Output: Health: 100
Console.WriteLine($"Alive: {hero.isAlive}"); // Output: Alive: True

Player weakling = new Player("Weakling", 10);
Console.WriteLine($"Name: {weakling.name}");     // Output: Name: Weakling
Console.WriteLine($"Health: {weakling.health}"); // Output: Health: 10
Console.WriteLine($"Alive: {weakling.isAlive}"); // Output: Alive: True

Constructor Overloading​

Like regular methods, constructors can be overloaded, meaning you can define multiple constructors with different parameter lists:

public class Enemy
{
    public string name;
    public int health;
    public int damage;
    public string type;
    
    // Parameterless constructor
    public Enemy()
    {
        name = "Minion";
        health = 50;
        damage = 5;
        type = "Normal";
    }
    
    // Constructor with name parameter
    public Enemy(string enemyName)
    {
        name = enemyName;
        health = 50;
        damage = 5;
        type = "Normal";
    }
    
    // Constructor with name and health parameters
    public Enemy(string enemyName, int initialHealth)
    {
        name = enemyName;
        health = initialHealth;
        damage = 5;
        type = "Normal";
    }
    
    // Constructor with all parameters
    public Enemy(string enemyName, int initialHealth, int attackDamage, string enemyType)
    {
        name = enemyName;
        health = initialHealth;
        damage = attackDamage;
        type = enemyType;
    }
}

// Usage
Enemy minion = new Enemy();                          // Uses 1st constructor
Enemy goblin = new Enemy("Goblin");                  // Uses 2nd constructor
Enemy orc = new Enemy("Orc", 100);                   // Uses 3rd constructor
Enemy dragon = new Enemy("Dragon", 500, 50, "Boss"); // Uses 4th constructor

Constructor overloading allows clients of your class to create objects with different levels of initialization, depending on what information is available.

Constructor Chaining​

When you have multiple constructors with overlapping initialization logic, you can use constructor chaining to avoid code duplication. This is done using the this keyword:

public class Enemy
{
    public string name;
    public int health;
    public int damage;
    public string type;
    
    // Primary constructor with all parameters
    public Enemy(string enemyName, int initialHealth, int attackDamage, string enemyType)
    {
        name = enemyName;
        health = initialHealth;
        damage = attackDamage;
        type = enemyType;
    }
    
    // Calls the primary constructor with default damage and type
    public Enemy(string enemyName, int initialHealth)
        : this(enemyName, initialHealth, 5, "Normal")
    {
        // No additional initialization needed
    }
    
    // Calls the constructor above with default health
    public Enemy(string enemyName)
        : this(enemyName, 50)
    {
        // No additional initialization needed
    }
    
    // Calls the constructor above with default name
    public Enemy()
        : this("Minion")
    {
        // No additional initialization needed
    }
}

In this example, each constructor calls another constructor using the this keyword, ultimately calling the primary constructor that does the actual initialization. This approach:

  • Reduces code duplication
  • Centralizes initialization logic
  • Makes maintenance easier

Constructor Execution Order​

When you create an object, constructors execute in a specific order:

  1. Memory is allocated for the object
  2. All fields are initialized to their default values
  3. The base class constructor is called (if applicable)
  4. Field initializers run in the order they appear in the class
  5. The constructor body executes

This order is important to understand, especially when working with inheritance (which we'll cover in a later section).

Object Initializers​

C# 3.0 introduced object initializers, which provide a concise syntax for initializing objects:

public class Item
{
    public string name;
    public int value;
    public string rarity;
    
    // Constructors
    public Item() { }
    
    public Item(string itemName)
    {
        name = itemName;
    }
}

// Using constructors
Item sword1 = new Item();
sword1.name = "Iron Sword";
sword1.value = 100;
sword1.rarity = "Common";

Item sword2 = new Item("Steel Sword");
sword2.value = 250;
sword2.rarity = "Uncommon";

// Using object initializers
Item sword3 = new Item { name = "Iron Sword", value = 100, rarity = "Common" };
Item sword4 = new Item("Steel Sword") { value = 250, rarity = "Uncommon" };

Object initializers call a constructor and then initialize the specified properties or fields. They provide a more concise way to initialize objects, especially when you need to set multiple properties.

Target-typed new Expressions (C# 9)​

C# 9 (supported by Unity 6.x) introduced target-typed new expressions, which allow you to omit the type when the target type is known:

// Traditional approach
Player player1 = new Player("Hero", 100);

// C# 9 target-typed new
Player player2 = new("Hero", 100);

// Works with object initializers too
Item sword = new() { name = "Iron Sword", value = 100, rarity = "Common" };

This feature makes your code more concise, especially when the type name is long or already obvious from the context.

Constructors in Unity​

In Unity, constructors work a bit differently for MonoBehaviour scripts:

  1. Don't Use Constructors for MonoBehaviours: Unity uses serialization to create and restore MonoBehaviour instances, which can bypass constructors. Instead, use Awake() or Start() for initialization.
// DON'T do this for MonoBehaviours
public class PlayerController : MonoBehaviour
{
    private int health;
    
    // This constructor might not be called by Unity!
    public PlayerController()
    {
        health = 100; // This initialization might be skipped
    }
}

// DO this instead
public class PlayerController : MonoBehaviour
{
    private int health;
    
    private void Awake()
    {
        health = 100; // Proper initialization in Unity
    }
}
  1. Constructors for Non-MonoBehaviour Classes: For regular C# classes that don't inherit from MonoBehaviour, constructors work normally and are the preferred way to initialize objects.
// Regular C# class (not a MonoBehaviour)
public class PlayerStats
{
    public int health;
    public int mana;
    public int strength;
    
    // Constructor works normally for non-MonoBehaviour classes
    public PlayerStats(int initialHealth, int initialMana, int initialStrength)
    {
        health = initialHealth;
        mana = initialMana;
        strength = initialStrength;
    }
}

// Usage in a MonoBehaviour
public class Player : MonoBehaviour
{
    private PlayerStats stats;
    
    private void Awake()
    {
        // Create PlayerStats using its constructor
        stats = new PlayerStats(100, 50, 10);
    }
}

Practical Examples​

Example 1: Weapon System​

public class Weapon
{
    // Properties
    public string Name { get; private set; }
    public int Damage { get; private set; }
    public float Range { get; private set; }
    public float AttackSpeed { get; private set; }
    public string Type { get; private set; }
    
    // Constructors
    public Weapon(string name, int damage, float range, float attackSpeed, string type)
    {
        Name = name;
        Damage = damage;
        Range = range;
        AttackSpeed = attackSpeed;
        Type = type;
    }
    
    // Predefined weapon constructors using constructor chaining
    public static Weapon CreateSword()
    {
        return new Weapon("Steel Sword", 15, 2f, 1.2f, "Melee");
    }
    
    public static Weapon CreateBow()
    {
        return new Weapon("Longbow", 10, 20f, 0.8f, "Ranged");
    }
    
    public static Weapon CreateStaff()
    {
        return new Weapon("Magic Staff", 20, 15f, 1.5f, "Magic");
    }
}

// Usage
public class Player : MonoBehaviour
{
    private Weapon currentWeapon;
    
    private void Start()
    {
        // Create a custom weapon
        currentWeapon = new Weapon("Excalibur", 30, 3f, 1.0f, "Legendary");
        
        // Or use a predefined weapon
        currentWeapon = Weapon.CreateBow();
        
        Debug.Log($"Equipped {currentWeapon.Name} with {currentWeapon.Damage} damage");
    }
}

Example 2: Enemy Factory​

public class Enemy
{
    // Properties
    public string Name { get; private set; }
    public int Health { get; private set; }
    public int Damage { get; private set; }
    public float Speed { get; private set; }
    
    // Constructor
    public Enemy(string name, int health, int damage, float speed)
    {
        Name = name;
        Health = health;
        Damage = damage;
        Speed = speed;
    }
    
    // Methods
    public void TakeDamage(int amount)
    {
        Health -= amount;
        if (Health < 0) Health = 0;
    }
    
    public bool IsAlive()
    {
        return Health > 0;
    }
}

public class EnemyFactory
{
    // Factory methods to create different types of enemies
    public static Enemy CreateGoblin()
    {
        return new Enemy("Goblin", 50, 5, 3.5f);
    }
    
    public static Enemy CreateOrc()
    {
        return new Enemy("Orc", 100, 10, 2.0f);
    }
    
    public static Enemy CreateDragon()
    {
        return new Enemy("Dragon", 500, 50, 1.5f);
    }
    
    // Create a random enemy
    public static Enemy CreateRandomEnemy()
    {
        int type = UnityEngine.Random.Range(0, 3);
        switch (type)
        {
            case 0: return CreateGoblin();
            case 1: return CreateOrc();
            default: return CreateDragon();
        }
    }
}

// Usage
public class EnemySpawner : MonoBehaviour
{
    private void SpawnEnemies()
    {
        Enemy goblin = EnemyFactory.CreateGoblin();
        Enemy orc = EnemyFactory.CreateOrc();
        Enemy dragon = EnemyFactory.CreateDragon();
        Enemy random = EnemyFactory.CreateRandomEnemy();
        
        Debug.Log($"Spawned: {goblin.Name}, {orc.Name}, {dragon.Name}, and {random.Name}");
    }
}

Example 3: Game Configuration​

public class GameConfig
{
    // Properties
    public string GameName { get; private set; }
    public int Difficulty { get; private set; }
    public bool EnableTutorial { get; private set; }
    public float MusicVolume { get; private set; }
    public float SfxVolume { get; private set; }
    
    // Default constructor with standard settings
    public GameConfig()
    {
        GameName = "My Awesome Game";
        Difficulty = 2; // Medium
        EnableTutorial = true;
        MusicVolume = 0.7f;
        SfxVolume = 0.8f;
    }
    
    // Constructor with custom settings
    public GameConfig(string gameName, int difficulty, bool enableTutorial, 
                     float musicVolume, float sfxVolume)
    {
        GameName = gameName;
        Difficulty = Mathf.Clamp(difficulty, 1, 5); // Ensure difficulty is between 1-5
        EnableTutorial = enableTutorial;
        MusicVolume = Mathf.Clamp01(musicVolume); // Ensure volume is between 0-1
        SfxVolume = Mathf.Clamp01(sfxVolume);
    }
    
    // Predefined configurations
    public static GameConfig EasyMode()
    {
        return new GameConfig("My Awesome Game", 1, true, 0.7f, 0.8f);
    }
    
    public static GameConfig HardMode()
    {
        return new GameConfig("My Awesome Game", 4, false, 0.7f, 0.8f);
    }
    
    public static GameConfig SilentMode()
    {
        return new GameConfig("My Awesome Game", 2, true, 0.0f, 0.3f);
    }
}

// Usage
public class GameManager : MonoBehaviour
{
    private GameConfig config;
    
    private void Start()
    {
        // Use default configuration
        config = new GameConfig();
        
        // Or use a predefined configuration
        config = GameConfig.HardMode();
        
        // Or create a custom configuration
        config = new GameConfig("Super Hard Mode", 5, false, 0.5f, 1.0f);
        
        Debug.Log($"Game started with difficulty: {config.Difficulty}");
    }
}

Best Practices for Constructors​

  1. Keep Constructors Simple: Constructors should focus on initializing the object to a valid state. Avoid complex logic or operations that could fail.

  2. Initialize All Fields: Ensure all fields are initialized to appropriate values, either through constructors or field initializers.

  3. Use Constructor Chaining: When you have multiple constructors, use constructor chaining to avoid code duplication.

  4. Consider Factory Methods: For complex object creation, consider using static factory methods instead of or in addition to constructors.

  5. Validate Parameters: Check constructor parameters for validity and throw appropriate exceptions if they're invalid.

  6. Don't Call Virtual Methods: Avoid calling virtual methods from constructors, as derived classes might not be fully initialized yet.

  7. For MonoBehaviours: Remember that Unity uses Awake() and Start() for initialization, not constructors.

Conclusion​

Constructors are essential for proper object initialization in C#. They ensure that objects start with a valid state and provide a clear way to specify initial values. By understanding how to define and use constructors effectively, you can create more robust and maintainable code for your Unity games.

In the next section, we'll explore access modifiers, which control the visibility and accessibility of your classes and their members.

Practice Exercise​

Exercise: Design a character creation system for an RPG game with the following requirements:

  1. Create a Character class with properties for name, class type (warrior, mage, rogue), health, mana, strength, dexterity, and intelligence.

  2. Implement multiple constructors:

    • A default constructor that creates a balanced character
    • A constructor that takes a name and class type, setting appropriate stats for each class
    • A constructor that allows full customization of all stats

  3. Use constructor chaining to avoid code duplication.

  4. Add validation to ensure stats are within reasonable ranges.

  5. Create several predefined character templates using static factory methods.

Test your implementation by creating different characters and displaying their stats.