b88d1c2c-38fa-596b-8ee4-2c460920ca14:undefined

Overview

Before you begin

What are namespaces?

Conditions for using a type from a namespace

Duplicated type names

Declare a type as part of a namespace

Nested namespaces

Summary

Namespaces

Namespaces are a fundamental aspect of scripting. By the end of this tutorial, you’ll be able to:

Games

Intermediate Scripting

This tutorial is part of Intermediate Scripting, a collection of basic introductions to a wide range of different programming concepts. If you want a guided introductory learning experience, try the Create with Code course or the full Junior Programmer pathway. 

Namespaces group together type definitions in order to encapsulate them into systems that work together. You can think of namespaces like folders in an operating system. Types within a namespace can use each other freely, but types that are not in the same namespace must be imported before you can use them.

In order to use a type from a namespace when you write a script, you need to meet one of three conditions:

Your script must contain a using directive for the namespace of the type that you want to use.

When you use the type, you must also include its namespace.

Your script must be part of the same namespace as the type that you want to use.

Include the using directive for the namespace of the type 

This condition is the one most commonly met in a script. The correct syntax for this approach of including types from other namespaces is to include the keyword using at the top of your script, followed by the name of the namespace. Here’s an example:

using UnityEngine;
public class PlayerMovement : MonoBehaviour
{
   // …
}

In this code example, the UnityEngine namespace is included. This means all types from the UnityEngine namespace are available for use in this script. These include common types such as MonoBehaviour, GameObject, Transform, Rigidbody and many others.

Include the namespace when you use the type

You can meet this condition by adding the name of the namespace before types that use it, connected by the dot operator. Here’s an example that uses this technique:

public class PlayerMovement : UnityEngine.MonoBehaviour
{
   // …
}

Including the namespace when you use a type is useful if you only want to use types from a namespace once or if you want to specify the difference between two identically named types.

Write your script in the same namespace as the type

You’ll learn more about this final condition later in this tutorial.

All types from the same namespace must have different names. However, types from different namespaces can have the same name. For example, both the UnityEngine and System namespaces have definitions for a type called Random. 

When you use a type with a name that exists in multiple namespaces, you must specify the actual type that you want to use. This can be done in two different ways:

You can add the name of the namespace before the type, as you discovered in the previous step.

You can add another using directive at the top of the script which specifies the default meaning of the type name throughout the script.

Here is an example of the second technique:

using UnityEngine;
using System;
using Random = UnityEngine.Random;
public class PlayerMovement : MonoBehaviour
{
   void Start()
   {
       float speed = Random.value;
       // …
   }
}

In this example, the Random type from the UnityEngine namespace is specified as what is meant whenever Random is used throughout the rest of the script.

You can declare a type as part of a namespace by including the type declaration within a namespace block. 

A namespace block has the following syntax: the keyword namespace followed by the name of the namespace. This name can be either an existing namespace or a new one. Here’s an example:

using UnityEngine;
namespace Player
{
   public class PlayerMovement : MonoBehaviour
   {
       // ...
   }
}

In this example, the PlayerMovement class is part of the Player namespace. In order to use the PlayerMovement type in other scripts, you would need to do one of the following three things:

Write your other scripts in the same namespace (the Player namespace).

Include a using directive for the Player namespace at the top of each script.

Specify the namespace whenever you use the PlayerMovement type (Player.PlayerMovement).

You can nest namespaces like folders in an operating system. To access nested namespaces and types within them, use the dot operator. The dot operator is a period which indicates the nested relationship of the namespaces. 

You can use nested namespaces to further organize systems and concepts within a project. For example, you could include all editor scripts in a parent namespace and then create nested namespaces for custom inspectors and various other  tools.

Let’s review an example of nested namespaces for each of the three ways that you can use a namespace.

namespace EditorTools.MapCreation
{
   public class Drawing
   {
       // ...
   }
}

using System.Collections;
public class AIManager
{
   // …
}

public class Inventory : MonoBehavior
{
   public System.Collections.List<Item> items;
}

In this tutorial, you reviewed the basics of using namespaces and their role as an organizational tool for types. 

If you are near the beginning of your game development journey, namespaces might feel unnecessary. However,  they are a useful tool and you should keep them in mind as your projects become larger and more complex.

Namespaces

1. Overview

2. Before you begin

3. What are namespaces?

4. Conditions for using a type from a namespace

5. Duplicated type names

6. Declare a type as part of a namespace

7. Nested namespaces

8. Summary

Complete this tutorial