Naamruimten in C#-programmering

In deze zelfstudie leren we over naamruimten, hoe deze te definiëren, toegang te krijgen tot de leden en hoe deze te gebruiken in een C#-programma.

Naamruimten worden in C# gebruikt om codes te ordenen en een niveau van scheiding te bieden. Ze kunnen worden beschouwd als een container die bestaat uit andere naamruimten, klassen, enz.

Een naamruimte kan de volgende typen als leden hebben:

1. Naamruimten (geneste naamruimte)
2. Klassen
3. Interfaces
4. Structuren
5. Afgevaardigden

We zullen deze onderwerpen in latere tutorials bespreken. Voorlopig houden we het bij klassen en naamruimten.

Naamruimten zijn niet verplicht in een C#-programma, maar spelen wel een belangrijke rol bij het schrijven van schonere codes en het beheren van grotere projecten.

Laten we het concept van naamruimte begrijpen met een realistisch scenario. We hebben een groot aantal bestanden en mappen op onze computer. Stel je voor hoe moeilijk het zou zijn om ze te beheren als ze in een enkele map worden geplaatst. Daarom plaatsen we gerelateerde bestanden en mappen in een aparte map. Dit helpt ons om onze gegevens goed te beheren.

Het concept van naamruimte is vergelijkbaar in C#. Het helpt ons bij het organiseren verschillende leden door verwante leden in dezelfde naamruimte te plaatsen.

Naamruimte lost ook het probleem op van naamgevingsconflict . Twee of meer klassen kunnen, wanneer ze in verschillende naamruimten worden geplaatst, dezelfde naam hebben.

Naamruimte definiëren in C#

We kunnen een naamruimte in C# definiëren met behulp van de naamruimte zoekwoord als:

namespace Namespace-Name
{
    //Body of namespace
}

Bijvoorbeeld:

namespace MyNamespace
{
    class MyClass
    {
        public void MyMethod()
        {
            System.Console.WriteLine("Creating my namespace");
		}
	}
}

In het bovenstaande voorbeeld is een naamruimte MyNamespace is gecreëerd. Het bestaat uit een klasse MyClass als zijn lid. MyMethod is een methode van klasse MyClass .

Toegang tot leden van naamruimte in C#

De leden van een naamruimte zijn toegankelijk via de dot(.) exploitant. De syntaxis voor toegang tot het lid van de naamruimte is:

Namespace-Name.Member-Name

Als we bijvoorbeeld een object van MyClass moeten maken, kan dit worden gedaan als,

MyNamespace.MyClass myClass = new MyNamespace.MyClass();

In latere tutorials zullen we het maken van objecten bespreken. Richt je nu even op hoe de klas MyClass is toegankelijk.

Voorbeeld 1:Introductie van naamruimte in C#-programma

using System;

namespace MyNamespace
{
    public class SampleClass
    {
        public static void myMethod()
        {
            Console.WriteLine("Creating my namespace");
        }
    }
}
 
namespace MyProgram
{
    public class MyClass
    {
        public static void Main()
        {
            MyNamespace.SampleClass.myMethod();
        }
    }
}

Wanneer we het programma uitvoeren, is de uitvoer:

Creating my namespace

In het bovenstaande programma hebben we onze eigen naamruimte MyNamespace . gemaakt en kreeg toegang tot zijn leden via Main() methode binnen MyClass . Zoals eerder gezegd, de dot (.) operator wordt gebruikt om toegang te krijgen tot het lid van de naamruimte.

In de Main() methode, myMethod() methode wordt aangeroepen met de dot (.) telefoniste.

Een naamruimte gebruiken in C# [Het gebruik van trefwoord]

Een naamruimte kan in een programma worden opgenomen met behulp van het trefwoord using. De syntaxis is,

using Namespace-Name;

Bijvoorbeeld,

using System;

Het voordeel van deze aanpak is dat we niet telkens de volledige naam van de leden van die naamruimte hoeven op te geven wanneer we deze openen.

Zodra de lijn

using System;

staat bovenaan het programma. We kunnen schrijven

Console.WriteLine("Hello World!");

In plaats van de volledig gekwalificeerde naam, d.w.z.

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

Geneste naamruimte in C#

Een naamruimte kan een andere naamruimte bevatten. Het wordt geneste naamruimte genoemd. De geneste naamruimte en zijn leden zijn ook toegankelijk via de dot (.) telefoniste.

De syntaxis voor het maken van geneste naamruimte is als volgt:

namespace MyNamespace
{
    namespace NestedNamespace
    {
        // Body of nested namespace
	}
}

Voorbeeld 2:Geneste naamruimte in C#

using System;
 
// Nested Namespace
namespace MyNamespace
{
    namespace Nested
    {
        public class SampleClass
        {
            public static void myMethod()
            {
                Console.WriteLine("Nested Namespace Example");
            }
        }
    }
}
 
namespace MyProgram
{
    public class MyClass
    {
        public static void Main()
        {
            MyNamespace.Nested.SampleClass.myMethod();
        }
    }
}

Wanneer we het programma uitvoeren, is de uitvoer:

Nested Namespace Example

Dit voorbeeld illustreert hoe geneste naamruimte kan worden geïmplementeerd in C#.

Hier hebben we nu een extra naamruimte in MyNamespace genaamd Nested . Dus, in plaats van MyNamespace.SampleClass.myMethod() . te gebruiken , we moeten MyNamespace.Nested.SampleClass.myMethod() . gebruiken .