Share via

Naamruimten en gebruiksrichtlijnen

Aanbeveling

Nieuw bij het ontwikkelen van software? Begin eerst met de handleiding Aan de slag. Ze introduceren naamruimten en using instructies tijdens het schrijven van uw eerste programma's.

Ervaren in een andere taal? Naamruimten in C# werken op dezelfde manier als pakketten in Java of modules in Python. Ga door naar de syntaxis die u nodig hebt.

Naamruimtedeclaraties en using instructies zijn gerelateerde taalfuncties. Met een naamruimtedeclaratie worden uw typen in een georganiseerde structuur geplaatst. Een naamruimte groepeert gerelateerde typen en voorkomt naamconflicten. Met een using richtlijn kan uw programma deze typen gebruiken op basis van hun eenvoudige namen. U hoeft bij elk gebruik niet het volledige pad naar de naamruimte te spellen.

U hebt al naamruimten gebruikt in elk C#-programma dat u hebt geschreven. Elk .NET-type behoort tot een naamruimte en elke using instructie boven aan een bestand verwijst naar een naamruimte. Bijvoorbeeld, Console en Math behoort tot de System naamruimte, zodat hun volledig gekwalificeerde namen zijn System.Console en System.Math. Verzamelingstypen zoals List<T> en Dictionary<TKey, TValue> behoren tot System.Collections.Generic. Met één using instructie voor een van deze naamruimten kunt u naar alle typen verwijzen op basis van hun eenvoudige namen. U schrijft List<T> in plaats van System.Collections.Generic.List<T> overal waar u het gebruikt.

In dit artikel vindt u meer achtergrondinformatie over de werking van naamruimten en using richtlijnen en ziet u voorbeelden van patronen die u al hebt aangetroffen in .NET-bibliotheken.

Een naamruimte bevat typen. Elk .NET-type behoort tot een naamruimte. Denk System.Threading.Tasks.Taskbijvoorbeeld aan: het type Task behoort tot de System.Threading.Tasks naamruimte.

Het is raadzaam gerelateerde of vergelijkbare typen in dezelfde naamruimte te groeperen en dat is wat .NET doet met de typen die worden geboden. De System.Collections.Generic naamruimte bevat verzamelingsgerelateerde typen en de System.IO naamruimte bevat typen gerelateerde lees- en schrijfbestanden, mappen en gegevens. De System naamruimte bevat fundamentele typen zoals Math, DateTimeen Console.

In het volgende voorbeeld ziet u hoe naamruimten samenwerken met using instructies in een typisch C#-bestand:

using System.Globalization;

namespace MyApp.Services;

class Greeter
{
    public string Greet(string name)
    {
        var culture = CultureInfo.CurrentCulture;
        return $"Hello, {name}! Culture: {culture.Name}";
    }
}

In het voorgaande voorbeeld betekent de using instructie dat u de System.Globalization.CultureInfo met de naam CultureInfo kunt gebruiken zonder de volledige naam van System.Globalization.CultureInfo op te geven. De namespace instructie verklaart dat de Greeter klasse deel uitmaakt van de MyApp.Services naamruimte. De volledig gekwalificeerde naam is MyApp.Services.Greeter.

Namespace-declaraties

Met een naamruimtedeclaratie worden uw typen toegewezen aan een benoemde groep. Elk type dat u schrijft, moet deel uitmaken van een naamruimte. De naam van de naamruimte weerspiegelt doorgaans de mapstructuur van uw project. Typen in een Services/Payments map behoren bijvoorbeeld vaak tot de MyApp.Services.Payments naamruimte.

Naamruimten gebruiken de . operator om hiërarchie uit te drukken, zoals System.Collections.Generic. Naamruimtenamen moeten geldige C# -id-namen zijn.

Naamruimten met bestandsbereik

Gebruik de syntaxis met bestandsbereik wanneer alle typen in een bestand deel uitmaken van dezelfde naamruimte. Voeg een puntkomma toe na de naamruimtedeclaratie en is van toepassing op het hele bestand. U hebt geen extra accolades of inspringing nodig:

namespace MyApp.Models;

class Customer
{
    public required string Name { get; init; }
    public string? Email { get; init; }

    public override string ToString() => $"{Name} ({Email ?? "no email"})";
}

Bestandsbereik naamruimten verminderen nesting en verbeteren de leesbaarheid van bestanden. U kunt slechts één naamruimtedeclaratie binnen het bestandsbereik per bestand hebben.

Aanbeveling

Gebruik in nieuwe code bestandsafgebakende naamruimten. De meeste .NET-sjablonen en codeanalyses raden deze stijl aan.

Naamruimten met blokbereik

Gebruik de syntaxis met blokbereik wanneer u meer dan één naamruimte in hetzelfde bestand moet declareren. Met deze stijl wordt een extra inspringingsniveau toegevoegd.

Belangrijk

Het wordt beschouwd als slecht om meer dan één naamruimte in hetzelfde bestand te declareren. Een gebruikelijker scenario is het gebruik van naamruimten met bestandsbereik.

Het volgende codefragment is een voorbeeld van een naamruimte met blokbereik :

namespace MyApp.Models
{
    class Product
    {
        public required string Name { get; init; }
        public decimal Price { get; init; }

        public override string ToString() => $"{Name}: {Price:C}";
    }
}

Instructies gebruiken

Zonder richtlijn using moet u naar elk type verwijzen op basis van de volledig gekwalificeerde naam, het volledige naamruimtepad plus de typenaam:

static void ShowFullyQualified()
{
    // Without a using directive, use the fully qualified name:
    System.Console.WriteLine("Hello from fully qualified name!");
}

Een using instructie boven aan een bestand importeert een naamruimte, zodat u de typen kunt gebruiken op basis van de eenvoudige namen:

static void ShowShortName()
{
    // With 'using System;' (or implicit usings enabled), use the short name:
    Console.WriteLine("Hello from short name!");
}

Zie de using richtlijn voor meer informatie.

Globale gebruiksrichtlijnen

Als u in elk bestand dezelfde using instructies schrijft, kunt u met behulp van globale instructies deze één keer declareren voor uw hele project. Plaats ze in een bestand. Veel teams maken een speciaal GlobalUsings.cs bestand:

global using System.Text;
global using System.Text.Json;

Nadat een globaal gebruik is gedeclareerd, kan elk bestand in het project verwijzen naar typen uit die naamruimte met behulp van eenvoudige namen zonder extra using instructie.

Impliciet gebruik

De .NET SDK genereert automatisch globale gebruiksrichtlijnen voor de meest voorkomende naamruimten op basis van uw projecttype. Schakel impliciet gebruik in door <ImplicitUsings>enable</ImplicitUsings> in uw projectbestand in te schakelen. Bijvoorbeeld, een console-app-project importeert automatisch System, System.Collections.Generic, System.IO, System.Linq, System.Threading en System.Threading.Tasks. De huidige SDK stelt ImplicitUsings in staat wanneer u een nieuw project maakt via dotnet new.

Zie Impliciet gebruik van instructies voor meer informatie.

Statisch met behulp van instructies

Met een static using richtlijn worden de statische leden van een type geïmporteerd, zodat u ze kunt aanroepen zonder het voorvoegsel van de typenaam:

using static System.Math;

namespace MyApp.Utilities;

class CircleCalculator
{
    public static double CalculateArea(double radius) => PI * Pow(radius, 2);

    public static double CalculateCircumference(double radius) => 2 * PI * radius;
}

Statisch gebruik werkt goed voor hulpprogrammaklassen zoals Math en Console die u vaak aanroept.

Typen en naamruimtealiassen

Een using alias maakt een verkorte naam voor een type of naamruimte. Aliassen zijn handig voor lange algemene typen, het oplossen van naamconflicten en het verbeteren van de leesbaarheid:

using CustomerList = System.Collections.Generic.List<MyApp.Models.Customer>;

namespace MyApp.Services;

class CustomerService
{
    public CustomerList GetTopCustomers()
    {
        CustomerList customers = [new() { Name = "Alice" }, new() { Name = "Bob" }];
        return customers;
    }
}

Vanaf C# 12 kunt u elk type alias gebruiken, inclusief tuples en aanwijzertypen:

using Point = (double X, double Y);

namespace MyApp.Geometry;

class Shape
{
    public static double Distance(Point a, Point b)
    {
        var dx = a.X - b.X;
        var dy = a.Y - b.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

Voor meer geavanceerde scenario's waarbij twee assembly's dezelfde volledig gekwalificeerde typenaam definiëren, gebruikt u een extern alias om onderscheid te maken tussen deze assembly's.

Verwante inhoud

  • Last updated on