C #: spazi dei nomi

UN namespaceè progettato per fornire un modo per mantenere un insieme di nomi separato da un altro. I nomi delle classi dichiarati in uno spazio dei nomi non sono in conflitto con gli stessi nomi delle classi dichiarati in un altro.

Definizione di uno spazio dei nomi

Una definizione di spazio dei nomi inizia con la parola chiave namespace seguito dal nome dello spazio dei nomi come segue:

namespace namespace_name {
   // code declarations
}

Per chiamare la versione abilitata per lo spazio dei nomi di una funzione o di una variabile, anteponi il nome dello spazio dei nomi come segue:

namespace_name.item_name;

Il seguente programma dimostra l'uso degli spazi dei nomi:

using System;

namespace first_space {
   class namespace_cl {
      public void func() {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space {
   class namespace_cl {
      public void func() {
         Console.WriteLine("Inside second_space");
      }
   }
}
class TestClass {
   static void Main(string[] args) {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Inside first_space
Inside second_space

La parola chiave utilizzando

Il usingla parola chiave indica che il programma sta utilizzando i nomi nello spazio dei nomi specificato. Ad esempio, stiamo usando ilSystemspazio dei nomi nei nostri programmi. La classe Console è definita lì. Scriviamo solo -

Console.WriteLine ("Hello there");

Avremmo potuto scrivere il nome completo come -

System.Console.WriteLine("Hello there");

Puoi anche evitare di anteporre gli spazi dei nomi con usingdirettiva namespace. Questa direttiva indica al compilatore che il codice successivo utilizza i nomi nello spazio dei nomi specificato. Lo spazio dei nomi è quindi implicito per il codice seguente:

Riscriviamo il nostro esempio precedente, usando la direttiva -

using System;
using first_space;
using second_space;

namespace first_space {
   class abc {
      public void func() {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space {
   class efg {
      public void func() {
         Console.WriteLine("Inside second_space");
      }
   }
}   
class TestClass {
   static void Main(string[] args) {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Inside first_space
Inside second_space

Spazi dei nomi annidati

È possibile definire uno spazio dei nomi all'interno di un altro spazio dei nomi come segue:

namespace namespace_name1 {
   
   // code declarations
   namespace namespace_name2 {
      // code declarations
   }
}

È possibile accedere ai membri dello spazio dei nomi nidificato utilizzando l'operatore punto (.) Come segue:

using System;
using first_space;
using first_space.second_space;

namespace first_space {
   class abc {
      public void func() {
         Console.WriteLine("Inside first_space");
      }
   }
   namespace second_space {
      class efg {
         public void func() {
            Console.WriteLine("Inside second_space");
         }
      }
   }   
}
class TestClass {
   static void Main(string[] args) {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Inside first_space
Inside second_space