Programar con el lenguaje de C# consta normalmente de uno o mas archivos, y es un efecto, ya que cuando creamos scripts para Unity normalmente nos tiende a dividirlo en archivos aparte (Movement.cs, Character.cs, Inventory.cs …). Cada archivo contiene espacios de nombres (namespaces) las cuales contienen clases, estructuras, interfaces, delegados, enumeraciones e incluso otros espacios de nombres anidados.

using System;

namespace MyGreatGame
{
		enum GameState
		{
				// Contenidos del enumerador
		}

		class GameScenes
		{
				// Contenido de la clase
		}

		struct SceneData
		{
				// Contenido del estructura
		}

		interface ITimer
		{
				// Instrucciones de la inferfaz
		}

		delegate int CurrentTime();

		namespace MyGreatFramework
		{
				// Contenido de espacio de trabajo anidado
		}
}

Separación de archivos

Es así como pueden existir dos archivos que compartan el mismo espacio de nombres y pertenezcan al mismo ensamblador, gracias a ello se conocerán entre ellos.

using System;

namespace MyGreatGame
{
		public class Item
		{
				// Variables ...
				public void SendToInventory()
				{
						// Contenido del método
				}
		}
}

using System;

namespace MyGreatGame
{
		public class Shop
		{
				enum ShopLocation
				{
						// Enumeradores que usa la tienda
				}

				private ShopLocation shopLocation; // Asignamos la estructura del enumerador en una variable
				private Item[] items; // Aqui nos estamos comunicando con la clase Item de Item.cs
				// Este tipo de conexión es un tipo de asociación llamada agregación

				public void SoldItem(Item item)
				{
						// Contenido del método
				}
		}
}

Importación de espacio de nombres

Ya con el previo conocimiento de la estructura y la importancia de los espacios de nombres podremos aprovechar de su bondades de importación, esto es debido a que cada elemento dentro del scope de dicho namespace se acumulará como en una especie de grupo que nos servirá para obtener sus referencias. Por ejemplo, hare un nuevo espacio de trabajo donde incluirá herramientas para importarla a mis juegos, lo llamaré MyGreatTools.

namespace MyGreatTools
 {
         public static class Compare
         {
                 public static Experience( float experience, int level, float ratio )
                 {
                         // Lógica interna del método
                 }
         }
 }

Ya este espacio de nombres se volvería una herramienta la cual contiene Compare y su me todo Experience el cual si lo importamos en otro script podremos utilizarle.

Ahora probemos importarlo en otro script con otro espacio de nombres totalmente diferente.

using MyGreatTools; // Al hacer esto importamos todo el espacio de nombres con su contenido
 namespace MyGreatGame
 {
         public class Game
         {
                 public void Start()
                 {
                         Compare.Experience(100f, 1, 0.5f); // Aquí no nos dará ningún problema con la referencia a las clase y método
                 }
         }
 }

Ya con ello podemos notar como las referencias tienen su cometido en modularizar el código y utilizarlo solo cuando lo necesitamos utilizando la palabra clave using y el nombre del espacio de nombres que contiene el código que necesitamos.

Lo mismo pasa con Unity, el cual posee DLLs que contienen dichos espacios de nombres que utilizamos la mayoría del tiempo como UnityEngine.UI, UnityEngine.AI o solamente UnityEngine la cual es necesaria para usar MonoBehaviour.

Los espacios de nombres son útiles

Más que una utilidad es una necesidad, el 99% de los casos es importante encapsular tu código en espacios de nombres, al menos en este lenguaje, debido a que abstraemos la información y modularizamos nuestro código; podremos hacer librerías, compilar DLL e importarlas en otros proyectos y ser más organizados a la hora de reutilizar nuestro propio código.