C# - Namespaces

Ein Namespace wurde entwickelt, um eine Möglichkeit zu bieten, eine Gruppe von Namen von einer anderen zu trennen. Die in einem Namensraum deklarierten Klassennamen stehen nicht in Konflikt mit denselben Klassennamen, die in einem anderen deklariert sind.

Definieren eines Namensraums

Eine Namespace-Definition beginnt mit dem Schlüsselwort namespace gefolgt vom Namespace-Namen wie folgt:−

namespace namespace_name {
   // code declarations
}

Um die Namespace-aktivierte Version einer Funktion oder Variablen aufzurufen, stellen Sie den Namespace-Namen wie folgt voran:−

namespace_name.item_name;

Das folgende Programm demonstriert die Verwendung von Namespaces −

Live-Demo

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();
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Inside first_space
Inside second_space

Die Verwendung Schlüsselwort

Die Verwendung Schlüsselwort gibt an, dass das Programm die Namen im angegebenen Namensraum verwendet. Zum Beispiel verwenden wir das System Namespace in unseren Programmen. Dort ist die Klasse Console definiert. Wir schreiben einfach −

Console.WriteLine ("Hello there");

Wir hätten den vollständig qualifizierten Namen auch als −

schreiben können

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

Sie können das Voranstellen von Namespaces auch mit using vermeiden Namespace-Direktive. Diese Direktive teilt dem Compiler mit, dass der nachfolgende Code Namen im angegebenen Namespace verwendet. Der Namensraum ist somit für den folgenden Code impliziert −

Lassen Sie uns unser vorheriges Beispiel mit der using-Direktive −

umschreiben Live-Demo

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();
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Inside first_space
Inside second_space

Verschachtelte Namespaces

Sie können einen Namensraum innerhalb eines anderen Namensraums wie folgt definieren −

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

Sie können auf Mitglieder des verschachtelten Namensraums zugreifen, indem Sie den Punktoperator (.) wie folgt verwenden −

Live-Demo

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();
   }
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Inside first_space
Inside second_space