Verwenden von Namespaces (C#-Programmierhandbuch)

Namespaces werden häufig in C# -Programmen auf zwei verschiedene Arten verwendet. Erstens: Die .NET Framework-Klassen verwenden Namespaces, um ihre zahlreichen Klassen zu organisieren. Zweitens: Eigene Namespaces zu deklarieren kann Ihnen dabei helfen, den Umfang der Klassen- und Methodennamen in größeren Programmierprojekten zu steuern.

Zugriff auf Namespaces

Die meisten C#-Anwendungen beginnen mit einem Abschnitt von using-Anweisungen. Dieser Abschnitt enthält die von der Anwendung häufig verwendeten Namespaces und erspart dem Programmierer die Angabe eines vollqualifizierten Namens bei jedem Verwenden einer enthaltenen Methode.

Z.B. durch das Einfügen der Zeile

using System;

Bei Programmstart kann der Programmierer folgenden Code verwenden:

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

anstelle von:

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

Namespacealiase

Die using-Anweisungen kann auch zum Erstellen eines Alias für einen Namespace verwendet werden. Wenn Sie einen bereits vorhandenen Namespace verwenden, der geschachtelte Namespaces enthält, können Sie einen Alias deklarieren, als schnelle Möglichkeit um auf einen bestimmten geschachtelten Namespace zu verweisen, wie im folgenden Beispiel gezeigt:

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

Verwenden von Namespaces zur Steuerung des Gültigkeitsbereichs

Mit dem Schlüsselwort namespace wird ein Bereich deklariert. Die Möglichkeit zum Erstellen von Bereichen innerhalb des Projekts, hilft Ihnen den Code zu organisieren und ermöglicht Ihnen die Erstellung von global eindeutigen Typen. Im folgenden Beispiel, wird eine Klasse mit dem Titel SampleClass in zwei ineinander geschachtelten Namespaces definiert. Die . Operator wird verwendet, um zu unterscheiden, 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();
        }
    }
}

Vollqualifizierte Namen

Namespaces und Typen verfügen über eindeutige durch den vollqualifizierten Namen, die eine logische Hierarchie an. Beispielsweise impliziert die Anweisung A.B, dass A der Name des Namespaces oder des Typs ist und, dass B darin geschachtelt ist.

Im folgenden Beispiel gibt es geschachtelte Klassen und Namespaces. Der vollqualifizierte Name ist als Kommentar angegeben, der auf jede Entität folgt.

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

Das vorherige Codesegment weist Folgendes auf:

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

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

  • Die Klasse C1 ist ein Mitglied von N1. Sein vollqualifizierter Name lautet N1.C1.

  • Der Klassenname C2 wird zweimal in diesem Code 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.

Mithilfe des vorhergehenden Codesegments können Sie dem Namespace N1.N2 ein neues Klassenmitglied C3 wie folgt hinzufügen:

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

Im Allgemeinen verwenden Sie ::, um auf einen Namespacealias, oder global::, um auf den globalen Namespace zu verweisen, und ., um Typen oder Mitglieder zu qualifizieren.

Die Verwendung von :: mit einem Alias, der auf einen Typ statt auf einen Namespace verweist ist ein Fehler. Zum Beispiel:

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

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

Beachten Sie, dass das Wort global kein vorderfinierter Alias ist; deshalb hat global.X keine spezielle Bedeutung. Er erhält erst dann eine besondere Bedeutung, wenn er mit :: verwendet wird.

Compilerwarnung CS0440 wird generiert, wenn Sie einen Alias mit dem Namen global definieren, da global:: immer ein Verweis auf den globalen Namespace und nicht auf einen Alias ist. Beispielsweise generiert die folgende Zeile die folgende Warnung:

using global = System.Collections;   // Warning

Die Verwendung von :: mit Aliasen ist ratsam, und verhindert die unbeabsichtigte Einführung von zusätzlichen Typen. Betrachten Sie beispielsweise 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 werden würde, würde Alias. an diesen Typ gebunden. Mit Alias::Exception wird sichergestellt, dass Alias als ein Namespacealias behandelt und nicht für einen Typ gehalten wird.

Finden Sie im Thema Vorgehensweise: Verwenden des globalen Namespacealias Informationen zum global Alias.

Siehe auch

C#-Programmierhandbuch
Namespaces
Namespace Keywords (Schlüsselwörter des Namespace)
. Operator
Operator ::
extern