Bagikan melalui

Namespace dan direktif penggunaan

Petunjuk / Saran

Baru mengembangkan perangkat lunak? Mulai dengan tutorial Memulai terlebih dahulu. Mereka memperkenalkan namespace dan arahan using saat Anda menulis program pertama Anda.

Berpengalaman dalam bahasa lain? Namespace dalam C# berfungsi mirip dengan paket di Java atau modul di Python. Langsung ke sintaksis yang Anda butuhkan.

Deklarasi namespace dan direktif using adalah fitur bahasa yang terkait. Deklarasi namespace menempatkan jenis Anda ke dalam struktur terorganisir. Namespace mengelompokkan jenis yang terkait dan mencegah tabrakan nama. Direktif using memungkinkan program Anda mengonsumsi jenis tersebut dengan nama sederhananya. Anda tidak perlu mengeja jalur namespace lengkap di setiap penggunaan.

Anda sudah menggunakan namespace dalam setiap program C# yang Anda tulis. Setiap jenis .NET milik sebuah namespace, dan setiap using direktif di bagian atas file mengacu pada satu. Misalnya, Console dan termasuk dalam Math namespace, sehingga nama mereka yang sepenuhnya memenuhi syarat adalah System dan System.ConsoleSystem.Math . Jenis koleksi seperti List<T> dan Dictionary<TKey, TValue> milik System.Collections.Generic. Satu using direktif untuk salah satu dari namespace ini memungkinkan Anda merujuk ke semua tipenya dengan nama sederhananya. Anda menulis List<T> alih-alih System.Collections.Generic.List<T> setiap kali Anda menggunakannya.

Artikel ini memberikan lebih banyak informasi latar belakang tentang cara kerja namespace dan using perintah, serta menunjukkan contoh pola yang sudah Anda kenal di pustaka .NET.

Namespace berisi jenis. Setiap tipe .NET milik namespace. Misalnya, pertimbangkan System.Threading.Tasks.Task: tipe Task termasuk dalam namespace System.Threading.Tasks.

Ini adalah praktik yang baik untuk mengelompokkan jenis terkait atau serupa di namespace yang sama, dan itulah yang dilakukan .NET dengan jenis yang disediakannya. Namespace System.Collections.Generic berisi jenis terkait koleksi dan System.IO namespace berisi jenis terkait membaca dan menulis file, direktori, dan data. Namespace System berisi jenis dasar seperti Math, DateTime, dan Console.

Contoh berikut menunjukkan cara namespace bekerja sama dengan using direktif dalam file C# umum:

using System.Globalization;

namespace MyApp.Services;

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

Dalam contoh sebelumnya, arahan using berarti Anda dapat menggunakan System.Globalization.CultureInfo dengan nama CultureInfo tanpa harus menyebutkan nama lengkap System.Globalization.CultureInfo. Direktif namespace menyatakan bahwa Greeter adalah kelas dari MyApp.Services namespace. Nama lengkapnya adalah MyApp.Services.Greeter.

Deklarasi namespace

Deklarasi namespace menetapkan tipe Anda ke dalam grup yang diberi nama. Setiap tipe yang Anda tulis harus masuk ke dalam satu namespace. Nama namespace biasanya mencerminkan struktur folder proyek Anda. Misalnya, tipe dalam Services/Payments folder sering berada dalam MyApp.Services.Payments namespace.

Namespace menggunakan . operator untuk mengekspresikan hierarki, seperti System.Collections.Generic. Nama namespace harus berupa nama pengidentifikasi C# yang valid.

Namespace dengan cakupan file

Gunakan sintaksis bercakupan file ketika semua jenis dalam file tersebut milik namespace yang sama. Tambahkan titik koma setelah deklarasi namespace, dan ini berlaku untuk seluruh file. Anda tidak memerlukan kurung kurawal atau indentasi tambahan:

namespace MyApp.Models;

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

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

Namespace dengan cakupan file mengurangi tingkat kedalaman dan membuat file lebih mudah dibaca. Anda hanya dapat memiliki satu deklarasi namespace dengan cakupan file untuk setiap file.

Petunjuk / Saran

Gunakan namespace cakupan file dalam kode baru. Sebagian besar templat .NET dan penganalisis kode merekomendasikan gaya ini.

Namespace cakupan blok

Gunakan sintaksis cakupan blok saat Anda perlu mendeklarasikan lebih dari satu namespace dalam file yang sama. Gaya ini menambahkan tingkat indentasi ekstra.

Penting

Ini dianggap praktik buruk untuk mendeklarasikan lebih dari satu namespace dalam file yang sama. Skenario yang lebih umum digunakan adalah menggunakan namespace cakupan file.

Cuplikan berikut adalah contoh namespace dengan ruang lingkup blok:

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

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

Menggunakan direktif

Tanpa direktif using, Anda harus merujuk ke setiap tipe dengan nama lengkap yang memenuhi syarat, jalur namespace lengkap ditambah nama tipe:

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

Direktif using di bagian atas file mengimpor namespace sehingga Anda dapat menggunakan jenisnya dengan nama sederhananya:

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

Untuk informasi selengkapnya, lihat arahanusing.

Penggunaan direktif global

Jika Anda menulis direktif yang sama using di setiap file, direktif global using memungkinkan Anda mendeklarasikannya sekali untuk seluruh proyek Anda. Tempatkan dalam file apa pun. Banyak tim membuat file khusus GlobalUsings.cs :

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

Setelah mendeklarasikan using global, setiap file dalam proyek dapat merujuk ke tipe dari namespace tersebut dengan menggunakan nama sederhana tanpa arahan tambahan using.

Penggunaan implisit

SDK .NET secara otomatis menghasilkan direktif penggunaan global untuk namespace yang paling umum berdasarkan jenis proyek Anda. Aktifkan penggunaan implisit dengan mengatur <ImplicitUsings>enable</ImplicitUsings> dalam file proyek Anda. Misalnya, proyek aplikasi konsol System, System.Collections.Generic, System.IO, System.Linq, System.Threading, dan System.Threading.Tasks secara otomatis mengimpor. SDK saat ini memungkinkan ImplicitUsings ketika Anda membuat proyek baru dengan menggunakan dotnet new.

Untuk informasi selengkapnya, lihat Implisit menggunakan arahan.

Statis menggunakan direktif

Direktif static using mengimpor anggota statis dari jenis sehingga Anda dapat memanggilnya tanpa awalan nama jenis:

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

Penggunaan statis berfungsi dengan baik untuk kelas utilitas seperti Math dan Console yang sering Anda panggil.

Alias tipe dan namespace

Alias using membuat nama singkat untuk tipe atau namespace. Alias berguna untuk jenis generik panjang, menyelesaikan konflik penamaan, dan meningkatkan keterbacaan:

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

Dimulai dengan C# 12, Anda dapat memberikan alias untuk tipe apa pun, termasuk tuple dan tipe pointer.

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

Untuk skenario yang lebih canggih di mana dua rakitan menentukan nama jenis yang sepenuhnya memenuhi syarat yang sama, gunakan alias ekstern untuk membedakan antara mereka.

Konten terkait

  • Last updated on