Verwenden von Namespaces (C#-Programmierhandbuch)

In C#-Programmen wird ausgiebig Gebrauch von Namespaces gemacht, wobei zwei Anwendungsfälle zu unterscheiden sind. Zum einen verwenden die Klassen von .NET Framework Namespaces, um die große Anzahl von Klassen zu organisieren. Zum anderen können Sie durch die Definition eines eigenen Namespaces die Steuerung des Gültigkeitsbereichs von Klassen- und Methodennamen in größeren Programmierprojekten unterstützen.

Zugriff auf Namespaces

Die meisten C#-Anwendungen beginnen mit einem Abschnitt von using-Direktiven. In diesem Abschnitt werden die Namespaces aufgelistet, die in der Anwendung häufig verwendet werden. So muss der Programmierer nicht bei jeder Verwendung einer Methode aus einem dieser Namespaces den vollqualifizierten Namen angeben.

So kann der Programmierer zum Beispiel durch das Einfügen der Zeile

using System;

an den Anfang eines Programms in der Folge den Code

Console.WriteLine("Hello, World!");

anstelle dieses Codes verwenden:

System.Console.WriteLine("Hello, World!");

Namespacealiase

Die using-Direktive kann auch verwendet werden, um einen Alias für einen Namespace zu erstellen. Wenn Sie zum Beispiel einen bereits vorhandenen Namespace verwenden, der geschachtelte Namespaces enthält, können Sie einen Alias erzeugen, um den Schnellzugriff auf einen bestimmten geschachtelten Namespace zu ermöglichen. Beispiel:

using Co = Company.Proj.Nested;  // define an alias to represent a namespace

Verwenden von Namespaces zur Steuerung des Gültigkeitsbereichs

Das namespace-Schlüsselwort wird verwendet, um einen Gültigkeitsbereich zu deklarieren. Durch die Möglichkeit, Gültigkeitsbereiche innerhalb eines Projekts zu definieren, wird die Organisation des Codes unterstützt. Zusätzlich lassen sich auf diese Art und Weise global eindeutige Typen erstellen. Im folgenden Beispiel wird eine Klasse mit dem Namen SampleClass in zwei Namespaces definiert, von denen einer in den anderen geschachtelt ist. Mit dem . Operator wird unterschieden, welche Methode aufgerufen wird.

namespace SampleNamespace
{
    class SampleClass
    {
        public void SampleMethod()
        {
            System.Console.WriteLine(
              "SampleMethod inside SampleNamespace");
        }
    }

    // Create a nested namespace, and define another class.
    namespace NestedNamespace
    {
        class SampleClass
        {
            public void SampleMethod()
            {
                System.Console.WriteLine(
                  "SampleMethod inside NestedNamespace");
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Displays "SampleMethod inside SampleNamespace."
            SampleClass outer = new SampleClass();
            outer.SampleMethod();

            // Displays "SampleMethod inside SampleNamespace."
            SampleNamespace.SampleClass outer2 = new SampleNamespace.SampleClass();
            outer2.SampleMethod();

            // Displays "SampleMethod inside NestedNamespace."
            NestedNamespace.SampleClass inner = new NestedNamespace.SampleClass();
            inner.SampleMethod();
        }
    }
}

Vollgekennzeichnete Namen

Namespaces und Typen verfügen über eindeutige Namen. Sie sind durch vollqualifizierte Namen beschrieben, die eine logische Hierarchie festlegen. So impliziert zum Beispiel die Anweisung A.B, dass A der Name des Namespaces oder Typs ist und dass B darin enthalten ist.

Das folgende Beispiel enthält geschachtelte Klassen und Namespaces. Der vollqualifizierte Name ist als Kommentar angegeben, der auf die einzelnen Entitäten folgt.

namespace N1     // N1
{
    class C1      // N1.C1
    {
        class C2   // N1.C1.C2
        {
        }
    }
    namespace N2  // N1.N2
    {
        class C2   // N1.N2.C2
        {
        }
    }
}

Das oben angegebene Codesegment weist Folgendes auf:

  • Der Namespace N1 ist ein Member des globalen Namespaces. Sein vollqualifizierter Name lautet N1.

  • Der Namespace N2 ist ein Member von N1. Sein vollqualifizierter Name lautet N1.N2.

  • Die Klasse C1 ist ein Member von N1. Ihr vollqualifizierter Name lautet N1.C1.

  • Der Klassenname C2 wird in diesem Code zweimal verwendet. Die vollqualifizierten Namen sind jedoch eindeutig. Die erste Instanz von C2 wird in C1 deklariert, daher lautet der vollqualifizierte Name N1.C1.C2. Die zweite Instanz von C2 wird in einem Namespace N2 deklariert, daher lautet der vollqualifizierte Name N1.N2.C2.

Im oben angegebenen Codesegment können Sie dem Namespace N1.N2 auf folgende Weise den neuen Klassenmember C3 hinzufügen:

namespace N1.N2
{
    class C3   // N1.N2.C3
    {
    }
}

Im Allgemeinen verweisen Sie mithilfe von :: auf einen Namespacealias und mithilfe von global:: auf den globalen Namespace, während Sie mit . Typen oder Member qualifizieren.

Die Verwendung von :: mit einem Alias, der auf einen Typ statt auf einen Namespace verweist, stellt einen Fehler dar. Beispiele:

using Alias = System.Console;
class TestClass
{
    static void Main()
    {
        // Error
        //Alias::WriteLine("Hi");

        // OK
        Alias.WriteLine("Hi");
    }
}

Beachten Sie, dass das Wort global kein vordefinierter Alias ist und global.X daher keine besondere Bedeutung hat. Eine besondere Bedeutung erhält der Ausdruck nur dann, wenn er mit :: verwendet wird.

Wenn Sie einen Alias mit dem Namen global erstellen, wird die Compilerwarnung CS0440 generiert, da global:: immer auf den globalen Namespace verweist, nicht jedoch auf einen Alias. Zum Beispiel wird bei folgender Zeile eine Warnung generiert:

using global = System.Collections;   // Warning

Die Verwendung von :: mit Aliasen ist grundsätzlich sehr empfehlenswert. Auf diese Weise wird die unbeabsichtigte Einführung zusätzlicher Typen verhindert. Betrachten Sie z. B. das folgende Beispiel:

using Alias = System;
namespace Library
{
    public class C : Alias.Exception { }
}

Dies funktioniert, aber wenn anschließend ein Typ mit dem Namen Alias eingeführt würde, würde Alias. an diesen Typ gebunden. Die Verwendung von Alias::Exception stellt sicher, dass Alias als Namespacealias behandelt und nicht mit einem Typ verwechselt wird.

Unter Gewusst wie: Verwenden des globalen Namespacealias finden Sie ausführlichere Informationen zum global-Alias.

Siehe auch

C#-Programmierhandbuch
Namespaces
Namespaceschlüsselwörter
. Operator
Operator ::
extern