Petunjuk `using`

2025-01-27

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 static mengimpor anggota static serta jenis berlapis dari satu jenis daripada mengimpor semua jenis dalam namespace layanan.

Anda dapat menggabungkan kedua pengubah untuk mengimpor anggota statis dari jenis ke 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 using kunci juga digunakan untuk membuat using pernyataan, yang membantu memastikan bahwa IDisposable objek seperti file dan font ditangani dengan benar. Untuk informasi selengkapnya tentang pernyataan tersebut, lihat using pernyataan.using

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

Direktif global using harus muncul sebelum semua namespace layanan dan deklarasi jenis. Semua global menggunakan direktif harus muncul dalam file sumber sebelum arahan nonglobal using apa pun.

Direktif lain using dapat muncul:

Di awal file kode sumber, sebelum namespace layanan atau deklarasi jenis apa pun.
Di namespace layanan yang diblokir, tetapi sebelum namespace atau jenis apa pun dideklarasikan dalam namespace layanan tersebut.

Jika tidak, kesalahan kompilator 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 arahan using berarti bahwa penggunaan diterapkan ke semua file dalam kompilasi (biasanya proyek):

global using <fully-qualified-namespace>;

Jika 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 dapat menambahkan global using direktif ke file sumber apa pun. Biasanya, Anda ingin menyimpannya di 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 dapat diterapkan ke direktif alias menggunakan. 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.

Penganalisis mengeluarkan diagnostik jika Anda menduplikasi global menggunakan arahan di lokasi yang berbeda. Penganalisis yang sama ini juga memberi tahu Anda jika Anda menambahkan using direktif untuk namespace layanan atau jenis yang sudah direktif global menggunakan referensi. Anda mungkin merasa lebih mudah untuk mengelola penggunaan Anda global dengan menyimpannya bersama-sama dalam satu file dalam proyek.

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 arahan 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 `static`

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

`using` 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.

Anggota alias yang memenuhi syarat

Kualifikasi alias namespace, :: menyediakan akses eksplisit ke namespace layanan global atau lainnya menggunakan alias yang berpotensi disembunyikan oleh entitas lain.

global:: memastikan bahwa pencarian namespace layanan untuk namespace mengikuti :: token relatif terhadap namespace global. Jika tidak, token harus diselesaikan ke menggunakan alias, dan token yang mengikuti harus diselesaikan ke jenis di namespace alias tersebut :: . Contoh berikut menunjukkan kedua formulir:

using S = System.Net.Sockets;

class A
{
    public static int x;
}

class C
{
    public void F(int A, object S)
    {
        // Use global::A.x instead of A.x
        global::A.x += A;

        // Using ::, S must resolve to a namespace alias:
        S::Socket s = S as S::Socket;

        // In this form, if S were a class, it would be a compile-time error:
        S.Socket s1 = S as S.Socket;
    }
}

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 global menggunakan pengubah, lihat global menggunakan spesifikasi fitur.

Bagikan melalui

Petunjuk using

Pengubah global

Pengubah static

using Alias