Spazio dei nomi (namespaces)

In uno dei primi articoli, abbiamo discusso brevemente dei namespaces. Probabilmente riconosci la parola chiave dato che la si trova solitamente in cima alla maggior parte dei files che contengono del codice c#. Un namespace è essenzialmente un modo per raggruppare un set di tipi, per esempio classi, in uno spazio di nome proprio. Quando Visual Studio genera un nuovo progetto, genera anche un namespace di base nella quale piazza il tuo primo file (vero per i progetti di tipo Console App). Il namespace può assomigliare a questo:

using System;  

namespace MyProject  
{  
    class Program  
    {  
    static void Main(string[] args)  
    {  
        // More code below this....

In questo caso, il namespace "MyProject" fa adesso parte dell'applicazione e quando si utilizzano le classi al di fuori di esso, bisognerà aggiungere un prefisso al nome della classe con il nome del namespace. Puoi trovare la stessa identica cosa quando usi qualcosa sepolta nel .NET framework, per esempio:

System.IO.File.ReadAllText("test.txt");

In questo caso, usiamo il metodo metodo ReadAllText() che si trova nella classe File che a sua volta esiste nel namespace System.IO . Naturalmente è faticoso dover scrivere un nome così lungo ogni singola volta che si vuole usare la classe dal namespace, quindi c# ci permette di "Importare" un intero namespace dentro il tuo file dichiarando using. Probabilmente li conosci già, dato che si trovano in cima dei files in C#. Per l'esempio sopra riportato, se abbiamo bisogno di usare la classe File più di una volta, ha senso importare il namespace System.IO dichiarandolo nel modo seguente:

using System;
using System.IO;
// More using statements here...

Perchè abbiamo bisogno dei namespaces?

Se hai appena iniziato a programmare, potresti chiederti a cosa servono i namespaces. Perchè non mettiamo tutte le classi in un singolo namespace così sono sempre accessibili?Domanda valida, ma solo se il progetto è davvero piccolo. Nel momento in cui si inizia ad aggiungere sempre più classi, ha molto piu senso separarle in piu namespaces. Questo ne rende più facile trovare il codice che cerchi, specialmente se salvi i tuoi files in cartelle corrispondenti - di fatto, se aggiungi cartelle al tuo progetto e dopodiche ne aggiungi classi, Visual Studio le aggiungerà automaticamente al namespace corrispondente. Quindi se crei una cartella in MyProject chiamata MyFolder, le classi aggiunge in questa cartella verranno aggiunte nel namespace MyProject.MyFolder come prefefinito.

Un ottimo esempio del perchè i namespaces sono necessari è il .NET framework. Basta pensare se TUTTE le classi nel framework galleggiassero in giro in un namespace globale - saremme un casino! Invece, sono organizzare piacevolmente, con System come namespace base per molte delle classi, sub-namespace come System.IO per cose di input e output, System.Net per cose relative ai network e System.Net.Mail per cose relative alle mail.

Conflitto di nomi con Namespaces

Come abbiamo menzionato in precedenza, i namespaces sono qui anche per incapsulare i tipo (solitamente classi), così che possano esistere nel loro proprio dominio. Questo significa essere liberi di creare classi con lo stesso nome di classi che si trovano altrove nel tuo progetto o anche nel .NET framework. Per esempio, potresti decidere di aver bisogno di una tua classe File . Come abbiamo visto nello scorso sempio, la classe File esiste già all'interno del namespace System.IO, ma sei comunque libero di crearne una nuova per il tuo namespace, ad esempio:

using System;  

namespace MyProject.IO  
{  
    class File  
    {  
    public static void HelloWorld()  
    {  
        Console.WriteLine("Hello, world!");  
    }  
    }  
}

Adesso quando vuoi utilizzala nel tuo progetto, nel metodo principare di Program.cs (se lavori in una Console App, come me), puoi scrivere il nome completo:

MyProject.IO.File.HelloWorld();

Oppure puoi anche importare il namespace, esattamente come gli altri namespace (integrati o definiti dagli utenti), grazie alla dichiarazione using. Ecco un esempio più complesso:

using System;
using MyProject.IO;

namespace MyProject
{
    class Program
    {
    static void Main(string[] args)
    {
        File.HelloWorld();
    }
    }
}

Fin qui tutto bene! Tuttavia, cosa succede se vogliamo usare anche la classe File del namespace System.IO?Qui è dove i problemi iniziano, dato che se importi anche quel namespace, con la dichiarazione using, il compilatore non sa più a che classe File ti riferisci - la tua o quella dal namespace System.IO. Questo puo essere risolto solamente importando uno dei due namespaces (idealmente quello che verrà utilizzato di più) e poi qualificando il nome dell'altro namespace, come nel esempio:

using System;
using System.IO;

namespace MyProject
{
    class Program
    {
    static void Main(string[] args)
    {
        MyProject.IO.File.HelloWorld();
    }
    }
}

Questo puo risultare un po ingombrante, specialmente se la tua classe è nidificata ancora di più nel namespace, esempio: MyProject.FileStuff.IO.File. Fortunatamente C# ha una soluzione per questo.

Using Alias Directive

Per abbreviare il nome del namespace di molto, puoi importare il namespace sotto un nome differente uttilizzando Using Alias Directive. Guarda come si fa nel esempio seguente:

using System;
using System.IO;
using MyIO = MyProject.IO;

namespace MyProject
{
    class Program
    {
    static void Main(string[] args)
    {
        File.ReadAllText("test.txt");
        MyIO.File.HelloWorld();
    }
    }
}

La magia avviene nella terza riga, dopo ho messo il namespace MyProject.IO e gli ho assegnato un nome abbreviato (MyIO), che piu avanti può essere utilizzato quando vogliamo accedercene. A questo punto, non stiamo salvando molto in termini di battiture, ma bisogna immaginare un nome ancora piu lungo e piu livelli di namespaces, e credimi, possono diventare parecchio lunghi e annidati.

Sommario

Namespaces ti danno l'opportunità di incapsulare i tuoi tipi in "spazzi nominati", che ti permettono di avere una struttura di codice migliore, oltre ad avere multiple classi con lo stesso nome, affinche esistano in namespaces separati.