Asset bundles and optimization in Unity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Unity C# code snippet?

Consider this code that loads an asset bundle asynchronously and prints the asset names. What will be printed in the console?

Unity

using UnityEngine;
using System.Collections;

public class LoadBundle : MonoBehaviour
{
    IEnumerator Start()
    {
        var bundleLoadRequest = AssetBundle.LoadFromFileAsync("Assets/Bundles/mybundle");
        yield return bundleLoadRequest;
        AssetBundle bundle = bundleLoadRequest.assetBundle;
        if (bundle == null)
        {
            Debug.Log("Failed to load bundle");
            yield break;
        }
        string[] assetNames = bundle.GetAllAssetNames();
        foreach (var name in assetNames)
        {
            Debug.Log(name);
        }
        bundle.Unload(false);
    }
}

A Prints all asset names inside the bundle, one per line

B Prints "Failed to load bundle" because LoadFromFileAsync does not exist

C Prints nothing because assetNames is always empty

D Throws a runtime error because bundle.Unload(false) is called too early

💡 Hint

Think about what LoadFromFileAsync returns and what GetAllAssetNames() does.

LoadFromFileAsync loads the bundle asynchronously. If successful, GetAllAssetNames returns all asset names inside the bundle. The code prints each name. The Unload(false) call unloads the bundle but keeps loaded assets in memory, so no error occurs.

🧠 Conceptual

intermediate

Which optimization technique reduces memory usage when loading asset bundles?

You want to optimize your Unity game to use less memory when loading asset bundles. Which technique helps achieve this?

A Load all asset bundles at game start and keep them loaded

B Avoid using asset bundles and load assets directly from Resources folder

C Load asset bundles synchronously to avoid overhead

D Use LoadFromFileAsync and unload bundles with Unload(false) after use

💡 Hint

Think about asynchronous loading and unloading bundles after use.

Loading bundles asynchronously avoids blocking the main thread. Unloading bundles with Unload(false) frees memory used by the bundle but keeps loaded assets usable, reducing memory footprint.

🔧 Debug

advanced

Why does this asset bundle loading code cause a NullReferenceException?

Examine the code below. It sometimes throws a NullReferenceException at runtime. What is the cause?

Unity

using UnityEngine;
using System.Collections;

public class BundleLoader : MonoBehaviour
{
    IEnumerator Start()
    {
        AssetBundle bundle = AssetBundle.LoadFromFile("Assets/Bundles/characters");
        string assetName = "hero";
        var asset = bundle.LoadAsset<GameObject>(assetName);
        Instantiate(asset);
        bundle.Unload(false);
        yield return null;
    }
}

A Calling bundle.Unload(false) before Instantiate unloads the asset causing null reference

B LoadFromFile returns null if the bundle path is wrong, causing bundle to be null

C The coroutine must yield before calling LoadFromFile to avoid null reference

D LoadAsset<GameObject> returns null if assetName is not found, causing Instantiate to fail

💡 Hint

Check if the bundle variable could be null before using it.

If the bundle path is incorrect or the bundle file is missing, LoadFromFile returns null. Then calling LoadAsset on null causes NullReferenceException.

📝 Syntax

advanced

Which option correctly loads an asset bundle asynchronously and accesses an asset?

Choose the code snippet that correctly loads an asset bundle asynchronously and then loads an asset named "tree" from it.

A

var request = AssetBundle.LoadFromFileAsync("path");
yield return request;
var bundle = request.assetBundle;
var asset = bundle.LoadAsset<GameObject>("tree");

B

var request = AssetBundle.LoadFromFileAsync("path");
var bundle = request.assetBundle;
var asset = bundle.LoadAsset<GameObject>("tree");

C

var bundle = AssetBundle.LoadFromFileAsync("path").assetBundle;
var asset = bundle.LoadAsset<GameObject>("tree");

D

var bundle = AssetBundle.LoadFromFile("path");
var asset = bundle.LoadAssetAsync<GameObject>("tree");

💡 Hint

Remember that asynchronous loading requires yielding until done.

Option A correctly yields the async request before accessing the assetBundle. Option A accesses assetBundle before loading completes. Option A tries to access assetBundle immediately. Option A uses LoadFromFile synchronously and LoadAssetAsync but does not yield.

🚀 Application

expert

How many asset bundles are loaded in memory after this code runs?

Given this Unity C# code, how many asset bundles remain loaded in memory after execution?

Unity

using UnityEngine;
using System.Collections;

public class BundleTest : MonoBehaviour
{
    IEnumerator Start()
    {
        var bundleA = AssetBundle.LoadFromFile("Assets/Bundles/bundleA");
        var bundleB = AssetBundle.LoadFromFile("Assets/Bundles/bundleB");
        var assetA = bundleA.LoadAsset<GameObject>("assetA");
        var assetB = bundleB.LoadAsset<GameObject>("assetB");
        bundleA.Unload(false);
        yield return null;
        // No unload called on bundleB
    }
}

A 2 bundles loaded

B 0 bundles loaded

C 1 bundle loaded

D Cannot determine without more info

💡 Hint

Consider what Unload(false) does and which bundles are unloaded.

bundleA is unloaded with Unload(false), which unloads the bundle but keeps loaded assets usable. bundleB is never unloaded, so it remains loaded in memory. Therefore, 1 bundle remains loaded.