Generics

Generics let you write a class or method once and use it with many types. The <T> is a placeholder for "some type, chosen later". You've already used them: GetComponent<Rigidbody>() and List<Enemy> are generics.

Using generics

Rigidbody rb = GetComponent<Rigidbody>();              // T = Rigidbody
List<Enemy> enemies = new List<Enemy>();               // T = Enemy
Dictionary<string, int> scores = new Dictionary<string, int>(); // two type parameters

enemies.Add(goblin);     // OK
// enemies.Add(coin);    // compile error: a Coin is not an Enemy

Before generics, collections stored object, so you had to cast everything back and could put the wrong thing in by accident. Generics catch those mistakes at compile time.

Writing a generic method

public static class RandomUtil
{
    // Works for an array of ANY type
    public static T Pick<T>(T[] items)
    {
        return items[Random.Range(0, items.Length)];
    }
}

// Usage: C# usually figures out T from the argument
AudioClip clip = RandomUtil.Pick(footstepClips);    // T = AudioClip
string line    = RandomUtil.Pick(greetings);        // T = string
GameObject pre = RandomUtil.Pick<GameObject>(enemyPrefabs); // or write T explicitly

Constraints: where T : ...

Sometimes your code needs T to be a certain kind of type. A constraint says so, and lets you use that type's members.

public static class GameObjectExtensions
{
    // T must be a Component, because AddComponent<T> only accepts components.
    // ("this GameObject go" makes it an extension method; see Extension Methods.)
    public static T GetOrAdd<T>(this GameObject go) where T : Component
    {
        if (!go.TryGetComponent(out T comp))
            comp = go.AddComponent<T>();
        return comp;
    }
}

// Usage
var audio = gameObject.GetOrAdd<AudioSource>();

Writing a generic class

A generic singleton base class: every manager gets the singleton behavior by inheriting from it.

using UnityEngine;

public abstract class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    public static T Instance { get; private set; }

    protected virtual void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this as T;
    }
}

public class GameManager : Singleton<GameManager>
{
    public int Score { get; set; }
}

public class AudioManager : Singleton<AudioManager>
{
    public void Play(AudioClip clip) { /* ... */ }
}

// Usage
GameManager.Instance.Score += 10;
AudioManager.Instance.Play(coinSound);

Each Singleton<GameManager> and Singleton<AudioManager> is a separate class with its own Instance, because static fields are separate for each T.

What happens at runtime

Common Mistakes

• GetComponent<IDamageable>() with a constraint that forbids it. Unity's own GetComponent<T> allows interfaces, but if your helper says where T : Component, interfaces won't compile. Drop the constraint or use a separate helper.
• Trying to use members without a constraint. Inside Pick<T>, you can't call item.name, because T could be anything. Add where T : UnityEngine.Object to use Unity object members.
• Over-engineering. Make something generic when you actually have two or more types that need it, not before.

See also

• Collections
• Extension Methods

This page is a simplified, AI-assisted interpretation. For the complete and authoritative reference, see the official Microsoft C# documentation.