Adding and removing components in Unity - Performance & Optimization

Performance: Adding and removing components

MEDIUM IMPACT

This affects frame rendering speed and responsiveness by changing the number of active components on GameObjects during gameplay.

Dynamically adding or removing components during gameplay

Unity

void Start() {
  cachedRigidbody = gameObject.GetComponent<Rigidbody>();
}

void ToggleRigidbody(bool enable) {
  if (enable && cachedRigidbody == null) {
    cachedRigidbody = gameObject.AddComponent<Rigidbody>();
  } else if (!enable && cachedRigidbody != null) {
    Destroy(cachedRigidbody);
    cachedRigidbody = null;
  }
}

Add or remove components only when necessary and cache references to avoid repeated costly calls.

📈 Performance GainReduces CPU spikes by limiting component changes to explicit events, not every frame.

Dynamically adding or removing components during gameplay

Unity

void Update() {
  if (Input.GetKeyDown(KeyCode.Space)) {
    gameObject.AddComponent<Rigidbody>();
  }
  if (Input.GetKeyDown(KeyCode.Backspace)) {
    Destroy(gameObject.GetComponent<Rigidbody>());
  }
}

Adding or removing components inside Update causes frequent CPU spikes and possible frame drops.

📉 Performance CostTriggers multiple script recompilations and internal Unity overhead per frame when keys are pressed.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Add/remove components every frame in Update	Many component adds/removes	Multiple script recompilations	High CPU usage	[X] Bad
Add/remove components on explicit events with caching	Few component changes	Single script recompilation per event	Low CPU usage	[OK] Good

Rendering Pipeline

Adding or removing components affects the scripting and physics update stages, causing Unity to recompile scripts and update internal component lists.

→Script Execution

→Physics Update

→Garbage Collection

⚠️ BottleneckScript Execution due to component initialization and destruction overhead

Core Web Vital Affected

INP

This affects frame rendering speed and responsiveness by changing the number of active components on GameObjects during gameplay.

Optimization Tips

1Avoid adding or removing components inside Update or other frequent loops.

2Cache component references to minimize repeated GetComponent calls.

3Batch component changes and trigger them only on explicit gameplay events.

Performance Quiz - 3 Questions

What is the main performance cost of adding components every frame in Unity?

A Frequent script recompilation and CPU spikes

B Increased GPU load

C More memory allocated for textures

D Slower network communication

DevTools: Unity Profiler

How to check: Open Unity Profiler, record gameplay, filter by 'Scripts' and 'GC', look for spikes during component add/remove calls

What to look for: High spikes in CPU usage and garbage collection during component changes indicate performance issues

Practice

1. What does the AddComponent<Type>() method do in Unity?

easy

A. Disables a GameObject temporarily

B. Adds a new component of the specified type to a GameObject

C. Removes a component from a GameObject

D. Creates a new GameObject in the scene

Solution

1. Step 1: Recall the purpose of AddComponent<Type>()

   This method adds a new component of the specified type to the GameObject it is called on.

2. Step 2: Rule out distractor options

   Removing components uses Destroy(), disabling is different, and creating GameObjects uses other methods.

3. Final Answer:

   Adds a new component of the specified type to a GameObject -> Option B

4. Quick Check:

   AddComponent<Type>() = Add component [OK]

Hint: AddComponent adds, Destroy removes components [OK]

Common Mistakes:

• Confusing AddComponent with Destroy
• Thinking AddComponent disables GameObjects
• Mixing up component addition with GameObject creation

2. Which of the following is the correct syntax to add a Rigidbody component to a GameObject named player?

easy

A. player.AddComponent(Rigidbody);

B. player.AddComponent<Rigidbody>();

C. player.AddComponent<Rigidbody>();

D. player.AddComponent<Rigidbody>;

Solution

1. Step 1: Recall correct generic syntax

   AddComponent uses generic syntax with angle brackets and parentheses: AddComponent<Type>()

2. Step 2: Inspect syntax of each option

   player.AddComponent<Rigidbody>(); is HTML-escaped but in actual code should be player.AddComponent<Rigidbody>(); which is correct syntax; others have syntax errors or missing parentheses.

3. Final Answer:

   player.AddComponent<Rigidbody>(); -> Option C

4. Quick Check:

   Correct generic syntax = player.AddComponent<Rigidbody>(); [OK]

Hint: Use angle brackets and parentheses: AddComponent<Type>() [OK]

Common Mistakes:

• Omitting parentheses after AddComponent
• Using parentheses instead of angle brackets
• Missing semicolon or wrong brackets

3. What will happen when the following code runs?

var enemy = new GameObject("Enemy");
var rb = enemy.AddComponent<Rigidbody>();
Destroy(rb);

medium

A. The enemy GameObject is destroyed

B. The Rigidbody component is added and remains on the enemy GameObject

C. The code causes a compile-time error

D. The Rigidbody component is added and then immediately removed from the enemy GameObject

Solution

1. Step 1: Analyze AddComponent call

   A Rigidbody component is added to the enemy GameObject and stored in variable rb.

2. Step 2: Analyze Destroy call

   Destroy(rb) removes the Rigidbody component, not the GameObject.

3. Final Answer:

   The Rigidbody component is added and then immediately removed from the enemy GameObject -> Option D

4. Quick Check:

   AddComponent + Destroy(component) = component removed [OK]

Hint: Destroy(component) removes that component, not the GameObject [OK]

Common Mistakes:

• Thinking Destroy(rb) deletes the whole GameObject
• Assuming component stays after Destroy
• Confusing compile error with runtime behavior

4. Identify the error in this code snippet that tries to remove a BoxCollider component:

var obj = new GameObject();
obj.AddComponent<BoxCollider>();
Destroy(obj.GetComponent<BoxCollider>);

medium

A. GetComponent<BoxCollider> is missing parentheses

B. AddComponent<BoxCollider>() is incorrect syntax

C. Destroy cannot be used on components

D. GameObject cannot have BoxCollider components

Solution

1. Step 1: Check GetComponent usage

   GetComponent<BoxCollider> is a method and requires parentheses to call it.

2. Step 2: Verify other parts

   AddComponent syntax is correct, Destroy works on components, and GameObjects can have BoxCollider.

3. Final Answer:

   GetComponent<BoxCollider> is missing parentheses -> Option A

4. Quick Check:

   Method calls need parentheses [OK]

Hint: Always add () when calling GetComponent [OK]

Common Mistakes:

• Forgetting parentheses on GetComponent
• Thinking Destroy can't remove components
• Confusing component types allowed on GameObjects

5. You want to add a Light component to a GameObject only if it doesn't already have one, and remove it later if a condition is met. Which code snippet correctly does this?

hard

A. if (obj.GetComponent<Light>() == null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); }

B. obj.AddComponent<Light>(); if (shouldRemove) { Destroy(obj.GetComponent<Light>); }

C. if (obj.GetComponent<Light> == null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); }

D. if (obj.GetComponent<Light>() != null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); }

Solution

1. Step 1: Check condition to add Light

   if (obj.GetComponent<Light>() == null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); } correctly checks if Light component is missing (null) before adding it.

2. Step 2: Check removal condition

   if (shouldRemove) { Destroy(obj.GetComponent<Light>()); } calls Destroy on the Light component with parentheses, correctly removing it if shouldRemove is true.

3. Step 3: Examine flaws in other options

   obj.AddComponent<Light>(); if (shouldRemove) { Destroy(obj.GetComponent<Light>); } adds Light without checking and misses parentheses in Destroy call. if (obj.GetComponent<Light> == null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); } misses parentheses in GetComponent check. if (obj.GetComponent<Light>() != null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); } adds Light if it already exists, which is wrong.

4. Final Answer:

   if (obj.GetComponent<Light>() == null) { obj.AddComponent<Light>(); } if (shouldRemove) { Destroy(obj.GetComponent<Light>()); } -> Option A

5. Quick Check:

   Check null before add, use Destroy(component) with () [OK]

Hint: Check null before adding; call Destroy with parentheses [OK]

Common Mistakes:

• Forgetting parentheses on GetComponent or Destroy
• Adding component without checking if it exists
• Removing component without calling method properly