Spații de nume

De obicei, clasele și alte tipuri definite în .NET nu există singure, ci sunt încapsulate în containere speciale numite spații de nume. Spațiile de nume permit organizarea codului programului în blocuri logice, permitând unirea și separarea unei anumite funcționalități de restul codului, funcționalitate care este legată de o idee comună sau care îndeplinește o anumită sarcină.

Pentru definirea unui spațiu de nume se folosește cuvântul cheie namespace, urmat de numele spațiului de nume:

namespace nume_spatiu_nume
{
   // conținutul spațiului de nume
}

De exemplu, să definim un spațiu de nume într-un fișier Program.cs care se va numi Base:

namespace Base
{
   class Person
   {
       string name;
       public Person(string name) => this.name = name;
       public void Print() => Console.WriteLine($"Nume: {name}");
   }
}

Aici spațiul de nume conține clasa Person, care are o variabilă name, un constructor și metoda Print.

Acum să încercăm să folosim clasa Person:

Person tom = new Person("Tom"); // Eroare - Visual Studio nu vede clasa Person
tom.Print();

namespace Base
{
   class Person
   {
       string name;
       public Person(string name) => this.name = name;
       public void Print() => Console.WriteLine($"Nume: {name}");
   }
}

Aici, pe prima linie, ne vom confrunta cu o eroare, deoarece Visual Studio nu poate găsi clasa Person. Pentru a accesa clasa Person, trebuie să folosim numele complet al acestei clase, incluzând spațiul de nume:

Base.Person tom = new("Tom");
tom.Print();          // Nume: Tom

namespace Base
{
   class Person
   {
       string name;
       public Person(string name) => this.name = name;
       public void Print() => Console.WriteLine($"Nume: {name}");
   }
}

Deoarece clasa Person se află în spațiul de nume Base, numele complet al acesteia este Base.Person. Astfel, folosind acest nume, putem accesa clasa respectivă în afara spațiului său de nume.

Conectarea spațiului de nume

Totuși, numele complet al clasei adaugă redundanță codului - mai ales dacă spațiul de nume conține mai multe clase pe care dorim să le folosim. Pentru a nu scrie numele complet al clasei, putem pur și simplu să conectăm spațiul de nume folosind directiva using:

using Base; // conectarea spațiului de nume Base

Person tom = new("Tom");
tom.Print();     // Nume: Tom

namespace Base
{
   class Person
   {
       string name;
       public Person(string name) => this.name = name;
       public void Print() => Console.WriteLine($"Nume: {name}");
   }
}

Spații de nume imbricate

Unele spații de nume pot conține altele. De exemplu:

namespace Base
{
   namespace PersonTypes
   {
       class Person
       {
           string name;
           OrganisationTypes.Company company;
           public Person(string name, OrganisationTypes.Company company)
           {
               this.name = name;
               this.company = company;
           }
           public void Print()
           {
               Console.WriteLine($"Nume: {name}");
               company.Print();
           }
       }
   }
   namespace OrganisationTypes
   {
       class Company
       {
           string title;
           public Company(string title) => this.title = title;
           public void Print() => Console.WriteLine($"Numele companiei: {title}");
       }
   }
}

În acest caz, clasele Person și Company se află în spații de nume imbricate diferite, așa că pentru a folosi clasa Company în clasa Person, trebuie să specificăm numele clasei, incluzând spațiul de nume: OrganisationTypes.Company (deoarece ambele clase se află în final în spațiul comun Base, nu este necesar să includem Base în numele clasei) sau să conectăm spațiul de nume al clasei Company folosind directiva using.

Pentru a accesa aceste clase în afara spațiului Base, trebuie să folosim întreaga cale a spațiului de nume:

using Base.PersonTypes; // conectarea spațiului de nume Base.PersonTypes pentru clasa Person

Base.OrganisationTypes.Company microsoft = new("Microsoft");
Person tom = new("Tom", microsoft);
tom.Print();     // Nume: Tom   Numele companiei: Microsoft

namespace Base
{
   namespace PersonTypes
   {
       class Person
       {
           string name;
           OrganisationTypes.Company company;
           public Person(string name, OrganisationTypes.Company company)
           {
               this.name = name;
               this.company = company;
           }
           public void Print()
           {
               Console.WriteLine($"Nume: {name}");
               company.Print();
           }
       }
   }
   namespace OrganisationTypes
   {
       class Company
       {
           string title;
           public Company(string title) => this.title = title;
           public void Print() => Console.WriteLine($"Numele companiei: {title}");
       }
   }
}

Spații de nume la nivel de fișier

Începând cu .NET 6 și C# 10, se pot defini spații de nume la nivel de fișier. De exemplu, să adăugăm un nou fișier cu cod C# în proiect. În Visual Studio, facem clic dreapta pe numele proiectului și în meniul apărut selectăm Add -> New Item...

În fereastra de adăugare a unui nou element, selectăm Class și în câmpul Name specificăm numele fișierului Base.cs.

După aceasta, în proiect va fi adăugat fișierul Base.cs. Ștergem conținutul implicit și definim următorul cod:

namespace Base;

class Person
{
   string name;
   public Person(string name) => this.name = name;
   public void Print() => Console.WriteLine($"Nume: {name}");
}

Directiva namespace Base de la începutul fișierului indică faptul că tot conținutul fișierului va aparține spațiului de nume Base.

Acum conectăm acest spațiu de nume în fișierul Program.cs:

using Base; // conectarea spațiului de nume Base

Person tom = new("Tom");
tom.Print();