Konvensi kode C# umum

Konvensi pengodean sangat penting untuk mempertahankan keterbacaan kode, konsistensi, dan kolaborasi dalam tim pengembangan. Kode yang mengikuti praktik industri dan pedoman yang ditetapkan lebih mudah dipahami, dipertahankan, dan diperluas. Sebagian besar proyek memberlakukan gaya yang konsisten melalui konvensi kode. Proyek dotnet/docs dan dotnet/samples tidak terkecuali. Dalam rangkaian artikel ini, Anda mempelajari konvensi pengkodean kami dan alat yang kami gunakan untuk menegakkannya. Anda dapat mengambil konvensi kami apa adanya, atau memodifikasinya agar sesuai dengan kebutuhan tim Anda.

Kami memilih konvensi kami berdasarkan tujuan berikut:

1. Kebenaran: Sampel kami disalin dan ditempelkan ke dalam aplikasi Anda. Kami mengharapkan itu, jadi kami perlu membuat kode yang tangguh dan benar, bahkan setelah beberapa pengeditan.
2. Pengajaran: Tujuan sampel kami adalah untuk mengajarkan semua .NET dan C#. Untuk alasan itu, kami tidak menerapkan pembatasan pada fitur bahasa atau API apa pun. Sebaliknya, sampel tersebut mengajarkan ketika fitur adalah pilihan yang baik.
3. Konsistensi: Pembaca mengharapkan pengalaman yang konsisten di seluruh konten kami. Semua sampel harus sesuai dengan gaya yang sama.
4. Adopsi: Kami secara agresif memperbarui sampel kami untuk menggunakan fitur bahasa baru. Praktik itu meningkatkan kesadaran akan fitur baru, dan membuatnya lebih akrab dengan semua pengembang C#.

Penting

Panduan ini digunakan oleh Microsoft untuk mengembangkan sampel dan dokumentasi. Mereka diadopsi dari panduan .NET Runtime, C# Coding Style dan kompiler C# (roslyn). Kami memilih panduan tersebut karena adopsinya selama beberapa tahun pengembangan perangkat lunak sumber terbuka. Panduan ini membantu anggota komunitas berpartisipasi dalam proyek runtime dan kompilator. Ini dimaksudkan untuk menjadi contoh konvensi C# umum, dan bukan daftar otoritatif (lihat Panduan Desain Kerangka Kerja untuk panduan terperinci).

Tujuan pengajaran dan adopsi adalah mengapa konvensi pengkodian dokumen berbeda dari konvensi runtime dan kompilator. Runtime dan kompilator memiliki metrik performa yang ketat untuk jalur eksekusi utama. Banyak aplikasi lain tidak memiliki fitur ini. Tujuan pengajaran kami mengamanatkan bahwa kami tidak melarang konstruksi apa pun. Sebagai gantinya, sampel menunjukkan kapan konstruksi harus digunakan. Kami memperbarui sampel secara lebih agresif daripada kebanyakan aplikasi produksi. Tujuan adopsi kami mengamanatkan bahwa kami menunjukkan kode yang harus Anda tulis hari ini, bahkan ketika kode yang ditulis tahun lalu tidak memerlukan perubahan.

Artikel ini menjelaskan panduan kami. Pedoman berevolusi dari waktu ke waktu, dan Anda akan menemukan sampel yang tidak mengikuti panduan kami. Kami menyambut PR yang membawa sampel tersebut ke kepatuhan, atau masalah yang menarik perhatian kami pada sampel yang harus kami perbarui. Pedoman kami bersifat Open Source dan kami menyambut permintaan perubahan (PR) dan permasalahan. Namun, jika pengajuan Anda akan mengubah rekomendasi ini, ajukan sebuah isu untuk diskusi terlebih dahulu. Anda dipersilakan untuk menggunakan panduan kami, atau menyesuaikannya dengan kebutuhan Anda.

Alat dan penganalisis

Alat dapat membantu tim Anda menerapkan konvensi Anda. Anda dapat mengaktifkan analisis kode untuk menerapkan aturan yang Anda inginkan. Anda juga dapat membuat konfigurasi editor sehingga Visual Studio secara otomatis menerapkan panduan gaya Anda. Sebagai titik awal, Anda dapat menyalin dotnet/docs.editorconfig untuk menggunakan gaya kami.

Alat-alat ini memudahkan tim Anda untuk mengadopsi pedoman pilihan Anda. Visual Studio menerapkan aturan pada semua file .editorconfig yang berada dalam cakupan untuk memformat kode Anda. Anda dapat menggunakan beberapa konfigurasi untuk memberlakukan konvensi di seluruh perusahaan, konvensi tim, dan bahkan konvensi proyek terperinci.

Analisis kode menghasilkan peringatan dan diagnostik saat mendeteksi pelanggaran aturan. Anda mengonfigurasi aturan yang ingin Anda terapkan ke proyek Anda. Kemudian, setiap build CI memberi tahu pengembang ketika mereka melanggar salah satu aturan.

ID diagnostik

• Pilih ID diagnostik yang sesuai saat membangun penganalisis Anda sendiri

Panduan bahasa

Bagian berikut menjelaskan praktik yang diikuti tim dokumen .NET untuk menyiapkan contoh dan sampel kode. Secara umum, ikuti praktik berikut:

• Gunakan fitur bahasa modern dan versi C# jika memungkinkan.
• Hindari konstruksi bahasa yang sudah usang.
• Hanya menangkap pengecualian yang dapat ditangani dengan benar; hindari menangkap pengecualian umum. Misalnya, kode sampel tidak boleh menangkap jenis System.Exception tanpa filter pengecualian.
• Gunakan jenis pengecualian tertentu untuk memberikan pesan kesalahan yang bermakna.
• Gunakan kueri dan metode LINQ untuk manipulasi koleksi untuk meningkatkan keterbacaan kode.
• Gunakan pemrograman asinkron dengan 'async' dan 'await' untuk operasi terikat I/O.
• Berhati-hatilah terhadap kebuntuan dan gunakan Task.ConfigureAwait jika sesuai.
• Gunakan kata kunci bahasa untuk jenis data alih-alih jenis runtime. Misalnya, gunakan string alih-alih System.String, atau int alih-alih System.Int32. Rekomendasi ini mencakup penggunaan jenis nint dan nuint.
• Gunakan int bukan tipe yang tidak ditandatangani. Penggunaan int umum di seluruh C#, dan lebih mudah untuk berinteraksi dengan pustaka lain saat Anda menggunakan int. Pengecualian adalah untuk dokumentasi khusus untuk jenis data yang tidak ditandatangani.
• Gunakan var hanya ketika pembaca dapat menyimpulkan jenis dari ekspresi. Pembaca meninjau sampel kami di platform dokumentasi. Mereka tidak memiliki hover atau tips alat yang menampilkan jenis variabel.
• Tulis kode dengan anggapan kejelasan dan kesederhanaan.
• Hindari logika kode yang terlalu kompleks dan berkonvolusi.

Panduan lebih spesifik akan diberikan berikutnya.

Data string

• Gunakan interpolasi string untuk menggabungkan string pendek, seperti yang ditunjukkan dalam kode berikut.

  string displayName = $"{nameList[n].LastName}, {nameList[n].FirstName}";
  

• Untuk menambahkan string dalam perulangan, terutama saat Anda bekerja dengan teks dalam jumlah besar, gunakan objek System.Text.StringBuilder.

  var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
  var manyPhrases = new StringBuilder();
  for (var i = 0; i < 10000; i++)
  {
      manyPhrases.Append(phrase);
  }
  //Console.WriteLine("tra" + manyPhrases);
  

• Lebih dianjurkan menggunakan string literal mentah untuk menghindari urutan escape atau string verbatim secara langsung.

  var message = """
      This is a long message that spans across multiple lines.
      It uses raw string literals. This means we can 
      also include characters like \n and \t without escaping them.
      """;
  

• Gunakan interpolasi string yang berbasis ekspresi daripada interpolasi string yang menggunakan posisi.

  // Execute the queries.
  Console.WriteLine("scoreQuery:");
  foreach (var student in scoreQuery)
  {
      Console.WriteLine($"{student.Last} Score: {student.score}");
  }
  

Konstruktor dan inisialisasi

• Gunakan kasus Pascal untuk parameter konstruktor utama pada jenis rekaman:

  public record Person(string FirstName, string LastName);
  

• Gunakan penulisan CamelCase untuk parameter konstruktor utama pada jenis kelas dan struktur.

• Gunakan properti required alih-alih konstruktor untuk memaksa inisialisasi nilai properti:

  public class LabelledContainer<T>(string label)
  {
      public string Label { get; } = label;
      public required T Contents 
      { 
          get;
          init;
      }
  }
  

Array dan Koleksi

• Gunakan ekspresi koleksi untuk menginisialisasi semua jenis koleksi:

string[] vowels = [ "a", "e", "i", "o", "u" ];

Delegasi

• Gunakan Func<> dan Action<> alih-alih mendefinisikan jenis delegasi. Dalam kelas, tentukan metode delegasi.

Action<string> actionExample1 = x => Console.WriteLine($"x is: {x}");

Action<string, string> actionExample2 = (x, y) =>
    Console.WriteLine($"x is: {x}, y is {y}");

Func<string, int> funcExample1 = x => Convert.ToInt32(x);

Func<int, int, int> funcExample2 = (x, y) => x + y;

• Panggil metode menggunakan tanda tangan yang ditentukan oleh delegasi Func<> atau Action<>.

actionExample1("string for x");

actionExample2("string for x", "string for y");

Console.WriteLine($"The value is {funcExample1("1")}");

Console.WriteLine($"The sum is {funcExample2(1, 2)}");

• Jika Anda membuat instans jenis delegasi, gunakan sintaks ringkas. Dalam kelas, tentukan jenis delegasi dan metode yang memiliki tanda tangan yang cocok.

  public delegate void Del(string message);
  
  public static void DelMethod(string str)
  {
      Console.WriteLine($"DelMethod argument: {str}");
  }
  

• Buat instans jenis delegasi dan panggil instans tersebut. Deklarasi berikut menunjukkan sintaks ringkas.

  Del exampleDel2 = DelMethod;
  exampleDel2("Hey");
  

• Deklarasi berikut menggunakan sintaks penuh.

  Del exampleDel1 = new Del(DelMethod);
  exampleDel1("Hey");
  

try-catchpernyataan dan using dalam penanganan pengecualian

• Gunakan pernyataan try-catch untuk sebagian besar penanganan pengecualian.

  static double ComputeDistance(double x1, double y1, double x2, double y2)
  {
      try
      {
          return Math.Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
      }
      catch (System.ArithmeticException ex)
      {
          Console.WriteLine($"Arithmetic overflow or underflow: {ex}");
          throw;
      }
  }
  

• Sederhanakan kode Anda dengan menggunakan pernyataan using C#. Jika Anda memiliki pernyataan try-finally di mana satu-satunya kode dalam blok finally adalah panggilan ke metode Dispose, gunakan pernyataan using sebagai gantinya.

  Dalam contoh berikut, pernyataan try-finally hanya memanggil Dispose di blok finally.

  Font bodyStyle = new Font("Arial", 10.0f);
  try
  {
      byte charset = bodyStyle.GdiCharSet;
  }
  finally
  {
      bodyStyle?.Dispose();
  }
  

  Anda dapat melakukan hal yang sama dengan pernyataan using.

  using (Font arial = new Font("Arial", 10.0f))
  {
      byte charset2 = arial.GdiCharSet;
  }
  

  Gunakan sintaks using baru yang tidak memerlukan kurung kurawal:

  using Font normalStyle = new Font("Arial", 10.0f);
  byte charset3 = normalStyle.GdiCharSet;
  

operator && dan ||

• Gunakan && alih-alih & dan || alih-alih | saat Anda melakukan perbandingan, seperti yang ditunjukkan dalam contoh berikut.

  Console.Write("Enter a dividend: ");
  int dividend = Convert.ToInt32(Console.ReadLine());
  
  Console.Write("Enter a divisor: ");
  int divisor = Convert.ToInt32(Console.ReadLine());
  
  if ((divisor != 0) && (dividend / divisor) is var result)
  {
      Console.WriteLine($"Quotient: {result}");
  }
  else
  {
      Console.WriteLine("Attempted division by 0 ends up here.");
  }
  

Jika pembagi adalah 0, klausul kedua dalam pernyataan if akan menyebabkan kesalahan run-time. Tetapi operator && berhenti ketika ekspresi pertama false. Maksudnya, tidak mengevaluasi ungkapan kedua. Operator & akan mengevaluasi keduanya, yang mengakibatkan kesalahan waktu proses ketika divisor adalah 0.

new pengoperasi

• Gunakan salah satu bentuk instansiasi objek ringkas saat jenis variabel cocok dengan jenis objek, seperti yang ditunjukkan dalam deklarasi berikut. Formulir ini tidak valid ketika variabel adalah jenis antarmuka, atau kelas dasar dari jenis runtime.

  var firstExample = new ExampleClass();
  

  ExampleClass instance2 = new();
  

  Deklarasi sebelumnya setara dengan deklarasi berikut.

  ExampleClass secondExample = new ExampleClass();
  

• Gunakan penginisialisasi objek untuk menyederhanakan pembuatan objek, seperti yang ditunjukkan dalam contoh berikut.

  var thirdExample = new ExampleClass { Name = "Desktop", ID = 37414,
      Location = "Redmond", Age = 2.3 };
  

  Contoh berikut menetapkan properti yang sama dengan contoh sebelumnya tetapi tidak menggunakan penginisialisasi.

  var fourthExample = new ExampleClass();
  fourthExample.Name = "Desktop";
  fourthExample.ID = 37414;
  fourthExample.Location = "Redmond";
  fourthExample.Age = 2.3;
  

Penanganan acara

• Gunakan ekspresi lambda untuk menentukan penanganan aktivitas yang tidak perlu Anda hapus nanti:

public Form2()
{
    this.Click += (s, e) =>
        {
            MessageBox.Show(
                ((MouseEventArgs)e).Location.ToString());
        };
}

Ekspresi lambda memperpendek definisi umum berikut.

public Form1()
{
    this.Click += new EventHandler(Form1_Click);
}

void Form1_Click(object? sender, EventArgs e)
{
    MessageBox.Show(((MouseEventArgs)e).Location.ToString());
}

Anggota statis

Panggil anggota statis dengan menggunakan nama kelas: ClassName.StaticMember. Praktik ini membuat kode lebih mudah dibaca dengan membuat akses statis menjadi jelas. Jangan kualifikasikan anggota statis yang ditentukan dalam kelas dasar dengan nama kelas turunan. Meskipun kode itu dikompilasi, keterbacaan kode menyesatkan, dan kode mungkin rusak di masa depan jika Anda menambahkan anggota statis dengan nama yang sama ke kelas turunan.

Kueri LINQ

• Menggunakan nama yang bermakna untuk variabel kueri. Contoh berikut menggunakan seattleCustomers untuk pelanggan yang berlokasi di Seattle.

  var seattleCustomers = from customer in Customers
                         where customer.City == "Seattle"
                         select customer.Name;
  

• Gunakan alias untuk memastikan bahwa nama properti dari jenis anonim dikapitalisasi dengan benar, menggunakan Pascal casing.

  var localDistributors =
      from customer in Customers
      join distributor in Distributors on customer.City equals distributor.City
      select new { Customer = customer, Distributor = distributor };
  

• Ganti nama properti ketika nama properti dalam hasil akan bersifat ambigu. Misalnya, jika kueri Anda mengembalikan nama pelanggan dan nama distributor, alih-alih membiarkannya sebagai bentuk Name dalam hasilnya, ganti namanya untuk mengklarifikasi CustomerName adalah nama pelanggan, dan DistributorName adalah nama distributor.

  var localDistributors2 =
      from customer in Customers
      join distributor in Distributors on customer.City equals distributor.City
      select new { CustomerName = customer.Name, DistributorName = distributor.Name };
  

• Gunakan pengetikan implisit dalam deklarasi variabel kueri dan variabel rentang. Panduan tentang pengetikan implisit dalam kueri LINQ ini mengambil alih aturan umum untuk variabel lokal yang diketik secara implisit. Kueri LINQ sering menggunakan proyeksi yang menghasilkan tipe anonim. Ekspresi kueri lainnya membuat hasil dengan jenis generik berlapis. Variabel implisit yang ditik sering lebih mudah dibaca.

  var seattleCustomers = from customer in Customers
                         where customer.City == "Seattle"
                         select customer.Name;
  

• Sejajarkan klausa kueri di bawah klausa from, seperti yang diperlihatkan dalam contoh sebelumnya.

• Gunakan klausa where sebelum klausul kueri lainnya untuk memastikan bahwa klausa kueri nanti beroperasi pada kumpulan data terfilter yang dikurangi.

  var seattleCustomers2 = from customer in Customers
                          where customer.City == "Seattle"
                          orderby customer.Name
                          select customer;
  

• Akses koleksi internal dengan menggunakan beberapa klausa from alih-alih klausa join. Misalnya, kumpulan objek Student mungkin masing-masingnya berisi koleksi skor pengujian. Saat kueri berikut dijalankan, kueri mengembalikan setiap skor yang lebih dari 90, bersama dengan nama keluarga siswa yang menerima skor.

  var scoreQuery = from student in students
                   from score in student.Scores
                   where score > 90
                   select new { Last = student.LastName, score };
  

Variabel lokal yang diketik secara implisit

• Gunakan pengetikan implisit untuk variabel lokal ketika jenis variabel jelas dari sisi kanan penugasan.

  var message = "This is clearly a string.";
  var currentTemperature = 27;
  

• Jangan gunakan var saat jenisnya tidak jelas dari sisi kanan penugasan. Jangan menganggap bahwa jenis tersebut sudah jelas hanya berdasarkan nama metode. Jenis variabel dianggap jelas jika merupakan operator new, casting eksplisit, atau penugasan ke sebuah nilai literal.

  int numberOfIterations = Convert.ToInt32(Console.ReadLine());
  int currentMaximum = ExampleClass.ResultSoFar();
  

• Jangan gunakan nama variabel untuk menentukan jenis variabel. Itu mungkin tidak benar. Sebagai gantinya, gunakan jenis untuk menentukan jenis, dan gunakan nama variabel untuk menunjukkan informasi semantik variabel. Contoh berikut harus digunakan string untuk jenis dan sesuatu seperti iterations untuk menunjukkan arti informasi yang dibaca dari konsol.

  var inputInt = Console.ReadLine();
  Console.WriteLine(inputInt);
  

• Hindari penggunaan var sebagai ganti dinamis. Gunakan dynamic saat Anda menginginkan inferensi jenis run-time. Untuk informasi selengkapnya, lihat Menggunakan jenis dinamis (Panduan Pemrograman C#).

• Gunakan pengetikan implisit untuk variabel perulangan dalam for loop.

  Contoh berikut menggunakan pengetikan implisit dalam pernyataan for.

  var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
  var manyPhrases = new StringBuilder();
  for (var i = 0; i < 10000; i++)
  {
      manyPhrases.Append(phrase);
  }
  //Console.WriteLine("tra" + manyPhrases);
  

• Jangan gunakan pengetikan implisit untuk menentukan jenis variabel perulangan dalam perulangan foreach. Dalam sebagian besar kasus, jenis elemen dalam koleksi tidak langsung jelas. Nama koleksi tidak boleh hanya diandalkan untuk menyimpulkan jenis elemennya.

  Contoh berikut menggunakan pengetikan eksplisit dalam pernyataan foreach.

  foreach (char ch in laugh)
  {
      if (ch == 'h')
      {
          Console.Write("H");
      }
      else
      {
          Console.Write(ch);
      }
  }
  Console.WriteLine();
  

• gunakan jenis implisit untuk urutan hasil dalam kueri LINQ. Bagian pada LINQ menjelaskan bahwa banyak kueri LINQ menghasilkan jenis anonim di mana jenis implisit harus digunakan. Kueri lain menghasilkan jenis generik berlapis di mana var lebih mudah dibaca.

  Catatan

  Berhati-hatilah agar tidak secara tidak sengaja mengubah jenis elemen dari koleksi yang dapat diulang. Misalnya, mudah untuk beralih dari System.Linq.IQueryable ke System.Collections.IEnumerable dalam pernyataan foreach, yang mengubah eksekusi kueri.

Beberapa sampel kami menjelaskan jenis ekspresi alami. Sampel tersebut harus digunakan var sehingga pengkompilasi memilih jenis alami. Meskipun contoh-contoh tersebut kurang jelas, penggunaan var diperlukan untuk sampel. Teks harus menjelaskan perilaku.

Deklarasi namespace dengan lingkup terbatas pada file

Sebagian besar file kode mendeklarasikan satu ruang nama. Oleh karena itu, contoh kita harus menggunakan deklarasi namespace lingkup file:

namespace MySampleCode;

Tempatkan direktif 'using' di luar deklarasi namespace

Ketika direktif using berada di luar deklarasi namespace, namespace yang diimpor adalah nama lengkapnya. Nama yang sepenuhnya memenuhi syarat lebih jelas. Ketika direktif using berada di dalam namespace, itu bisa relatif terhadap namespace tersebut, atau menggunakan nama lengkap yang memenuhi syarat.

using Azure;

namespace CoolStuff.AwesomeFeature
{
    public class Awesome
    {
        public void Stuff()
        {
            WaitUntil wait = WaitUntil.Completed;
            // ...
        }
    }
}

Dengan asumsi ada referensi (langsung, atau tidak langsung) ke WaitUntil kelas .

Sekarang, mari kita ubah sedikit:

namespace CoolStuff.AwesomeFeature
{
    using Azure;

    public class Awesome
    {
        public void Stuff()
        {
            WaitUntil wait = WaitUntil.Completed;
            // ...
        }
    }
}

Dan berhasil dikompilasi hari ini. Dan besok. Tetapi kemudian beberapa minggu depan kode sebelumnya (tidak tersentuh) gagal dengan dua kesalahan:

- error CS0246: The type or namespace name 'WaitUntil' could not be found (are you missing a using directive or an assembly reference?)
- error CS0103: The name 'WaitUntil' does not exist in the current context

Salah satu dependensi yang memperkenalkan kelas ini di namespace kemudian diakhir dengan .Azure:

namespace CoolStuff.Azure
{
    public class SecretsManagement
    {
        public string FetchFromKeyVault(string vaultId, string secretId) { return null; }
    }
}

Direktif using yang ditempatkan di dalam suatu namespace bersifat peka konteks dan mempersulit pemecahan nama. Dalam contoh ini, ini adalah namespace pertama yang ditemukannya.

• CoolStuff.AwesomeFeature.Azure
• CoolStuff.Azure
• Azure

Menambahkan namespace baru yang cocok dengan CoolStuff.Azure atau CoolStuff.AwesomeFeature.Azure akan cocok sebelum namespace global Azure. Anda dapat mengatasinya dengan menambahkan pengubah global:: ke using deklarasi. Namun, lebih mudah untuk menempatkan using deklarasi di luar namespace sebagai gantinya.

namespace CoolStuff.AwesomeFeature
{
    using global::Azure;

    public class Awesome
    {
        public void Stuff()
        {
            WaitUntil wait = WaitUntil.Completed;
            // ...
        }
    }
}

Panduan gaya

Secara umum, gunakan format berikut untuk sampel kode:

• Gunakan empat spasi untuk indentasi. Jangan gunakan tab.
• Sejajarkan kode secara konsisten untuk meningkatkan keterbacaan.
• Batasi baris hingga 65 karakter untuk meningkatkan keterbacaan kode pada dokumen, terutama pada layar seluler.
• Tingkatkan kejelasan dan pengalaman pengguna dengan memecah pernyataan panjang menjadi beberapa baris.
• Gunakan gaya "Allman" untuk kurung kurawal: buka dan tutup kurung pada baris baru masing-masing. Tanda kurung kurawal menyelaraskan dengan tingkat indentasi saat ini.
• Pemisah baris harus terjadi sebelum operator biner, jika perlu.

Gaya komentar

• Gunakan komentar baris tunggal (//) untuk penjelasan singkat.

• Hindari komentar multibaris (/* */) untuk penjelasan yang lebih panjang.
  Komentar dalam sampel kode tidak dilokalkan. Itu berarti penjelasan yang disematkan dalam kode tidak diterjemahkan. Teks penjelasan yang lebih panjang harus ditempatkan di artikel pendamping, agar dapat disesuaikan dengan lokal.

• Untuk menjelaskan metode, kelas, bidang, dan semua anggota publik menggunakan komentar XML.

• Tempatkan komentar pada baris terpisah, bukan di akhir baris kode.

• Mulailah teks komentar dengan huruf besar.

• Akhiri teks komentar dengan titik.

• Sisipkan satu spasi antara pemisah komentar (//) dan teks komentar, seperti yang diperlihatkan dalam contoh berikut.

  // The following declaration creates a query. It does not run
  // the query.
  

Konvensi tata letak

Tata letak yang baik menggunakan pemformatan untuk menekankan struktur kode Anda dan untuk membuat kode lebih mudah dibaca. Contoh dan sampel Microsoft sesuai dengan konvensi berikut:

• Gunakan pengaturan Editor Kode default (inden cerdas, inden empat karakter, tab yang disimpan sebagai spasi). Untuk informasi selengkapnya, lihat Opsi, Editor Teks, C#, Pemformatan.

• Tulis hanya satu pernyataan per baris.

• Tulis hanya satu deklarasi per baris.

• Jika baris kelanjutan tidak diindentasi secara otomatis, beri inden satu perhentian tab (empat spasi).

• Tambahkan setidaknya satu baris kosong antara definisi metode dan definisi properti.

• Gunakan tanda kurung untuk membuat klausa dalam ekspresi yang terlihat, seperti yang diperlihatkan dalam kode berikut.

  if ((startX > endX) && (startX > previousX))
  {
      // Take appropriate action.
  }
  

Pengecualian adalah ketika sampel menjelaskan prioritas operator atau ekspresi.

Keamanan

Ikuti panduan dalam Panduan Pengodean Aman.