menggunakan direktif

Artikel
04/25/2024

Direktif using memungkinkan Anda untuk menggunakan jenis yang ditentukan dalam namespace layanan tanpa menentukan namespace layanan yang sepenuhnya memenuhi syarat dari jenis tersebut. Dalam bentuk dasarnya, direktif using mengimpor semua jenis dari satu namespace layanan, seperti yang ditunjukkan dalam contoh berikut ini:

using System.Text;

Anda dapat menerapkan dua pengubah ke direktif using:

Pengubah global mempunyai efek yang sama dengan menambahkan direktif using yang sama ke setiap file sumber dalam proyek Anda. Pengubah ini diperkenalkan di C# 10.
Pengubah static mengimpor anggota static serta jenis berlapis dari satu jenis daripada mengimpor semua jenis dalam namespace layanan.

Anda bisa menggabungkan kedua pengubah untuk mengimpor anggota statik dari jenis di semua file sumber dalam proyek Anda.

Anda juga bisa membuat alias untuk namespace layanan atau jenis dengan direktif alias using.

using Project = PC.MyCompany.Project;

Anda bisa menggunakan pengubah global pada direktif alias using.

Catatan

Kata kunci using juga digunakan untuk membuat pernyataan using, yang membantu memastikan bahwa objek IDisposable seperti file serta font ditangani dengan benar. Untuk informasi selengkapnya tentang pernyataan penggunaan, lihat menggunakan pernyataan.

Cakupan dari direktif using tanpa pengubah global adalah file tempat kemunculannya.

Direktif using bisa muncul:

Di awal file kode sumber, sebelum namespace layanan atau deklarasi jenis apa pun.
Di namespace layanan apa pun, tetapi sebelum namespace layanan atau jenis apa pun yang dideklarasikan dalam namespace layanan tersebut, kecuali pengubah global digunakan, dalam hal ini direktif harus muncul sebelum semua namespace layanan dan deklarasi jenis.

Jika tidak, kesalahan kompilator CS1529 dihasilkan.

Buat direktif using untuk menggunakan jenis di namespace layanan tanpa harus menentukan namespace layanan. Direktif using tidak memberi Anda akses ke namespace layanan apa pun yang ditumpuk di namespace layanan yang Anda tentukan. Namespace layanan hadir dalam dua kategori: ditentukan pengguna serta ditentukan sistem. Namespace layanan yang ditentukan pengguna adalah namespace layanan yang ditentukan dalam kode Anda. Untuk daftar namespace layanan yang ditentukan sistem, lihat Browser .NET API.

pengubah global

Menambahkan pengubah global ke direktif using berarti bahwa penggunaan diterapkan ke semua file dalam kompilasi (biasanya proyek). Direktif global using ditambahkan dalam C# 10. Sintaksnya adalah:

global using <fully-qualified-namespace>;

di mana namespace layanan yang sepenuhnya memenuhi syarat adalah nama namespace layanan yang sepenuhnya memenuhi syarat yang jenisnya dapat dirujuk tanpa menentukan namespace layanan.

Direktif using global bisa muncul di awal file kode sumber apa pun. Semua direktif global using dalam satu file harus muncul sebelum:

Semua direktif using tanpa pengubah global.
Semua namespace layanan dan deklarasi jenis dalam file.

Anda bisa menambahkan direktif global using ke file sumber apa pun. Biasanya, Anda harus menyimpannya dalam satu lokasi. Urutan direktif global using tidak masalah, baik dalam satu file, atau di antara file.

Pengubah global dapat dikombinasikan dengan pengubah static. Pengubah global bisa diterapkan ke direktif alias using. Dalam kedua kasus, cakupan direktif merupakan semua file dalam kompilasi saat ini. Contoh berikut memungkinkan penggunaan semua metode yang dideklarasikan dalam System.Math di semua file dalam proyek Anda:

global using static System.Math;

Anda juga dapat menyertakan namespace layanan secara global dengan menambahkan item <Using> ke file proyek Anda, misalnya, <Using Include="My.Awesome.Namespace" />. Untuk informasi lebih lanjut, lihat <Using> item.

Penting

Templat C# untuk .NET 6 menggunakan pernyataan tingkat atas. Aplikasi Anda mungkin tidak cocok dengan kode dalam artikel ini, jika Anda telah meningkatkan ke .NET 6. Untuk informasi selengkapnya, lihat artikel mengenai Templat C# baru menghasilkan pernyataan tingkat atas

.NET 6 SDK juga menambahkan serangkaian direktif implisitglobal using untuk proyek yang menggunakan SDK berikut:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Direktif global using implisit ini mencakup namespace layanan yang paling umum untuk jenis proyek.

Untuk informasi selengkapnya, lihat artikel tentang Implisit menggunakan direktif

pengubah statik

Direktif using static menamai jenis yang anggota statiknya serta jenis berlapis yang bisa Anda akses tanpa menentukan nama jenis. Sintaksnya adalah:

using static <fully-qualified-type-name>;

<fully-qualified-type-name> adalah nama jenis yang anggota statik serta jenis berlapisnya bisa direferensikan tanpa menentukan nama jenis. Jika Anda tidak memberikan nama jenis yang sepenuhnya memenuhi syarat (nama namespace layanan lengkap bersama dengan nama jenis), C# menghasilkan kesalahan pengompilasi CS0246: "Jenis atau nama namespace layanan 'type/namespace' tidak dapat ditemukan (apakah Anda kehilangan menggunakan direktif atau referensi perakitan?)".

Direktif using static berlaku untuk jenis apa pun yang mempunyai anggota statik (atau jenis berlapis), bahkan jika juga memiliki anggota instans. Namun, anggota instans hanya bisa dipanggil melalui instans jenis.

Anda bisa mengakses anggota statik dari jenis tanpa harus memenuhi syarat akses dengan nama jenis:

using static System.Console;
using static System.Math;
class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4));
    }
}

Biasanya, saat Anda memanggil anggota statik, Anda memberikan nama jenis bersama dengan nama anggota. Berulang kali memasukkan nama jenis yang sama untuk memanggil anggota jenis dapat berakibat pada kode verbose dan tidak jelas. Misalnya, definisi kelas Circle berikut merujuk banyak anggota kelas Math.

using System;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * Math.PI; }
   }

   public double Area
   {
      get { return Math.PI * Math.Pow(Radius, 2); }
   }
}

Dengan menghilangkan kebutuhan untuk secara eksplisit mereferensikan kelas Math setiap kali anggota direferensikan, direktif using static menghasilkan kode yang lebih bersih:

using System;
using static System.Math;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}

using static hanya mengimpor anggota statik yang bisa diakses dan jenis berlapis yang dideklarasikan dalam jenis yang ditentukan. Anggota yang diwariskan tidak diimpor. Anda bisa mengimpor dari jenis bernama apa pun dengan direktifusing static, termasuk modul Visual Basic. Jika fungsi tingkat atas F# muncul dalam metadata sebagai anggota statik dari jenis bernama yang namanya adalah pengidentifikasi C# yang valid, maka fungsi F# bisa diimpor.

using static membuat metode ekstensi yang dideklarasikan dalam jenis yang ditentukan yang tersedia untuk pencarian metode ekstensi. Akan tetapi, nama metode ekstensi tidak diimpor ke dalam cakupan untuk referensi yang tidak memenuhi syarat dalam kode.

Metode dengan nama yang sama diimpor dari berbagai jenis dengan direktif using static yang berbeda dalam unit kompilasi atau namespace layanan yang sama membentuk grup metode. Resolusi kelebihan beban dalam grup metode ini mengikuti aturan C# normal.

Contoh berikut menggunakan direktif using static untuk membuat anggota statik kelas Console, Math, serta String tersedia tanpa harus menentukan nama jenisnya.

using System;
using static System.Console;
using static System.Math;
using static System.String;

class Program
{
   static void Main()
   {
      Write("Enter a circle's radius: ");
      var input = ReadLine();
      if (!IsNullOrEmpty(input) && double.TryParse(input, out var radius)) {
         var c = new Circle(radius);

         string s = "\nInformation about the circle:\n";
         s = s + Format("   Radius: {0:N2}\n", c.Radius);
         s = s + Format("   Diameter: {0:N2}\n", c.Diameter);
         s = s + Format("   Circumference: {0:N2}\n", c.Circumference);
         s = s + Format("   Area: {0:N2}\n", c.Area);
         WriteLine(s);
      }
      else {
         WriteLine("Invalid input...");
      }
   }
}

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}
// The example displays the following output:
//       Enter a circle's radius: 12.45
//
//       Information about the circle:
//          Radius: 12.45
//          Diameter: 24.90
//          Circumference: 78.23
//          Area: 486.95

Dalam contoh, direktif using static juga dapat diterapkan ke jenis Double. Menambahkan direktif tersebut akan memungkinkan untuk memanggil metode TryParse(String, Double) tanpa menentukan nama jenis. Namun, menggunakan TryParse tanpa nama jenis membuat kode yang kurang dapat dibaca, karena menjadi perlu untuk memeriksa direktif using static untuk menentukan metode TryParse jenis numerik mana yang dipanggil.

using static juga berlaku untuk jenis enum. Dengan menambahkan using static dengan enum, jenis tidak lagi diperlukan untuk menggunakan anggota enum.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

class Program
{
    public static void Main()
    {
        Color color = Green;
    }
}

menggunakan alias

Buat direktif using alias untuk mempermudah kualifikasi pengidentifikasi ke namespace layanan atau jenis. Dalam direktif using apa pun, namespace layanan atau jenis yang sepenuhnya memenuhi syarat harus digunakan terlepas dari direktif using yang datang sebelumnya. Tidak ada alias using yang bisa digunakan dalam deklarasi direktif using. Misalnya, kode berikut menghasilkan kesalahan pengompilasi:

using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.

Contoh berikut menunjukkan cara menentukan dan menggunakan alias using untuk namespace layanan:

namespace PC
{
    // Define an alias for the nested namespace.
    using Project = PC.MyCompany.Project;
    class A
    {
        void M()
        {
            // Use the alias
            var mc = new Project.MyClass();
        }
    }
    namespace MyCompany
    {
        namespace Project
        {
            public class MyClass { }
        }
    }
}

Direktif alias penggunaan tidak bisa memiliki jenis generik terbuka di sisi kanan. Misalnya, Anda tidak bisa membuat menggunakan alias untuk List<T>, tetapi Anda bisa membuatnya untuk List<int>.

Contoh berikut menunjukkan cara menentukan direktif using dan alias using untuk kelas:

using System;

// Using alias directive for a class.
using AliasToMyClass = NameSpace1.MyClass;

// Using alias directive for a generic class.
using UsingAlias = NameSpace2.MyClass<int>;

namespace NameSpace1
{
    public class MyClass
    {
        public override string ToString()
        {
            return "You are in NameSpace1.MyClass.";
        }
    }
}

namespace NameSpace2
{
    class MyClass<T>
    {
        public override string ToString()
        {
            return "You are in NameSpace2.MyClass.";
        }
    }
}

namespace NameSpace3
{
    class MainClass
    {
        static void Main()
        {
            var instance1 = new AliasToMyClass();
            Console.WriteLine(instance1);

            var instance2 = new UsingAlias();
            Console.WriteLine(instance2);
        }
    }
}
// Output:
//    You are in NameSpace1.MyClass.
//    You are in NameSpace2.MyClass.

Dimulai dengan C# 12, Anda dapat membuat alias untuk jenis yang sebelumnya dibatasi, termasuk jenis tuple, jenis penunjuk, dan jenis tidak aman lainnya. Untuk informasi selengkapnya tentang aturan yang diperbarui, lihat spesifikasi fitur.

Spesifikasi bahasa C#

Untuk informasi selengkapnya, lihat Menggunakan direktif di Spesifikasi Bahasa C#. Spesifikasi bahasa adalah sumber definitif untuk sintaks dan penggunaan C#.

Untuk informasi selengkapnya tentang pengubah using global, lihat spesifikasi fitur using global - C# 10.

Bagikan melalui

menggunakan direktif

pengubah global

pengubah statik

menggunakan alias

Spesifikasi bahasa C#

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: