Yaygın C# kod kuralları

Kodlama kuralları, bir geliştirme ekibinde kod okunabilirliği, tutarlılık ve işbirliğini korumak için gereklidir. Sektör uygulamalarını ve belirlenmiş yönergeleri izleyen kodu anlamak, korumak ve genişletmek daha kolaydır. Çoğu proje, kod kuralları aracılığıyla tutarlı bir stil uygular. dotnet/docs ve dotnet/samples projeleri özel durum değildir. Bu makale serisinde kodlama kurallarımızı ve bunları zorunlu kılmak için kullandığımız araçları öğreneceksiniz. Kurallarımızı olduğu gibi alabilir veya ekibinizin gereksinimlerine uyacak şekilde değiştirebilirsiniz.

Kurallarımızı aşağıdaki hedeflere göre seçtik:

1. Doğruluk: Örneklerimiz kopyalanır ve uygulamalarınıza yapıştırılır. Bunu bekliyoruz, bu nedenle birden çok düzenlemeden sonra bile dayanıklı ve doğru kodlar yapmamız gerekir.
2. Öğretim: Örneklerimizin amacı tüm .NET ve C# derslerini vermektir. Bu nedenle, herhangi bir dil özelliğine veya API'ye kısıtlama eklemeyiz. Bunun yerine, bu örnekler bir özelliğin iyi bir seçim olduğunu öğretir.
3. Tutarlılık: Okuyucular içeriğimizde tutarlı bir deneyim bekler. Tüm örnekler aynı stile uygun olmalıdır.
4. Benimseme: Örneklerimizi yeni dil özelliklerini kullanacak şekilde hızlı bir şekilde güncelliyoruz. Bu uygulama, yeni özelliklerin farkındalığını artırarak tüm C# geliştiricilerine daha tanıdık olmalarını sağlar.

Önemli

Bu yönergeler Microsoft tarafından örnekler ve belgeler geliştirmek için kullanılır. .NET Çalışma Zamanı, C# Kodlama Stili ve C# derleyicisi (roslyn) yönergelerinden benimsenmiştir. Bu yönergeleri, birkaç yıllık Açık Kaynak geliştirme sürecinde benimsenmelerinden dolayı seçtik. Bu yönergeler, topluluk üyelerinin çalışma zamanı ve derleyici projelerine katılmasına yardımcı olur. Bunlar, yetkili bir liste değil ortak C# kurallarına örnek olarak tasarlanmıştır (ayrıntılı yönergeler için bkz. Çerçeve Tasarım Yönergeleri).

Öğretim ve benimseme hedefleri, docs kodlama kuralının çalışma zamanı ve derleyici kurallarından farklı olmasının nedenidir. Hem çalışma zamanı hem de derleyici, sık erişimli yollar için katı performans ölçümlerine sahiptir. Diğer birçok uygulama bunu yapamaz. Öğretim hedefimiz, herhangi bir yapıyı yasaklamamamızı zorunlu kılınıyor. Bunun yerine örnekler, yapıların ne zaman kullanılması gerektiğini gösterir. Örnekleri çoğu üretim uygulamasından daha agresif bir şekilde güncelleştiriyoruz. Benimseme hedefimiz, geçen yıl yazılmış kodlarda değişiklik gerekmese bile bugün yazmanız gereken kodu göstermemizi zorunlu kılmıştır.

Bu makalede yönergelerimiz açıklanmaktadır. Yönergeler zaman içinde gelişir ve yönergelerimizi izlemeyen örnekler bulabilirsiniz. Bu örnekleri uyumlu hale getiren PR'leri veya güncelleştirmemiz gereken örneklere dikkatimizi çeken sorunları memnuniyetle karşılıyoruz. Yönergelerimiz Açık Kaynak'tır ve PR'leri ve sorunları memnuniyetle karşılarız. Ancak, gönderiminiz bu önerileri değiştirirse, önce tartışma için bir sorun açın. Yönergelerimizi kullanabilir veya ihtiyaçlarınıza göre uyarlayabilirsiniz.

Araçlar ve çözümleyiciler

Araçlar, ekibinizin kurallarınızı uygulamalarına yardımcı olabilir. Tercih ettiğiniz kuralları zorunlu kılmak için kod analizini etkinleştirebilirsiniz. Visual Studio'nun stil yönergelerinizi otomatik olarak uygulaması için bir editorconfig dosyası oluşturabilirsiniz. Başlangıç noktası olarak, stilimizi kullanmak için dotnet/docs.editorconfig kopyalayabilirsiniz.

Bu araçlar, ekibinizin tercih ettiğiniz yönergeleri benimsemesini kolaylaştırır. Visual Studio, kodunuzu biçimlendirmek için kapsamdaki tüm .editorconfig dosyalarındaki kuralları uygular. Şirket genelinde kuralları, ekip kurallarını ve hatta ayrıntılı proje kurallarını zorunlu kılmak için birden çok yapılandırma kullanabilirsiniz.

Kod analizi, kural ihlallerini algıladığında uyarılar ve tanılamalar üretir. Projenize uygulanmasını istediğiniz kuralları yapılandırabilirsiniz. Ardından her CI derlemesi, kuralların herhangi birini ihlal ettiğinde geliştiricilere bildirir.

Tanılama kimlikleri

• Kendi çözümleyicilerinizi oluştururken uygun tanılama kimliklerini seçin

Dil yönergeleri

Aşağıdaki bölümlerde, .NET docs ekibinin kod örneklerini ve örneklerini hazırlamak için izlediği uygulamalar açıklanmaktadır. Genel olarak şu uygulamaları izleyin:

• Mümkün olduğunda modern dil özelliklerini ve C# sürümlerini kullanın.
• Eski dil yapılarından kaçının.
• Yalnızca düzgün bir şekilde işlenebilecek olan özel durumları yakalayın; genel özel durumları yakalamaktan kaçının. Örneğin, örnek kod özel durum filtresi olmadan System.Exception türünü yakalamamalıdır.
• Anlamlı hata iletileri sağlamak için belirli özel durum türlerini kullanın.
• Kod okunabilirliğini geliştirmek için koleksiyon düzenlemesi için LINQ sorgularını ve yöntemlerini kullanın.
• Zaman uyumsuz programlama için async ve await anahtar sözcüklerini kullanarak G/Ç'ye bağlı işlemler gerçekleştirin.
• Kilitlenmelere karşı dikkatli olun ve uygun olduğunda kullanın Task.ConfigureAwait .
• Çalışma zamanı türleri yerine veri türleri için dil anahtar sözcüklerini kullanın. Örneğin, yerine stringveya System.String yerine intkullanınSystem.Int32. Bu öneri, nint ve nuinttürlerinin kullanılmasını içerir.
• İmzasız türler yerine kullanın int . Bu int kullanımı, C# genelinde yaygındır ve int kullanırken diğer kitaplıklarla etkileşime geçmek daha kolaydır. Özel durumlar, imzalanmamış veri türlerine özgü belgeler içindir.
• Yalnızca bir okuyucu ifadeden tür çıkarabildiğinde kullanın var . Okuyucular örneklerimizi docs platformunda görüntüler. Değişkenlerin türünü görüntüleyen fareyle üzerine gelme veya araç ipuçları yoktur.
• Netlik ve basitliği göz önünde bulundurarak kod yazın.
• Aşırı karmaşık ve karmaşık kod mantığını kullanmaktan kaçının.

Daha ayrıntılı yönergelere uyun.

Dize verileri

• Aşağıdaki kodda gösterildiği gibi kısa dizeleri birleştirmek için dize ilişkilendirmesini kullanın.

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

• Özellikle büyük miktarda metinle çalışırken dizeleri döngülere eklemek için bir System.Text.StringBuilder nesne kullanın.

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

• Kaçış dizileri veya kelimesi kelimesine dizeler yerine ham dize sabitlerini tercih edin.

  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.
      """;
  

• Konumsal dize ilişkilendirmesi yerine ifade tabanlı dize ilişkilendirmesini kullanın.

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

Oluşturucular ve başlatma

• Kayıt türlerinde birincil oluşturucu parametreleri için Pascal biçimini kullanın.

  public record Person(string FirstName, string LastName);
  

• Sınıf ve yapı türlerinde birincil oluşturucu parametreleri için camel case kullanın.

• Özellik değerlerinin başlatılmasını zorlamak için oluşturucular yerine required özellikleri kullanın:

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

Diziler ve koleksiyonlar

• Tüm koleksiyon türlerini başlatmak için koleksiyon ifadelerini kullanın:

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

Temsilciler

• Temsilci türleri tanımlamak yerine Func<> ve Action<> kullanın. Bir sınıfta temsilci yöntemini tanımlayın.

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;

• veya Func<> temsilcisi tarafından tanımlanan imzayı kullanarak yöntemini çağırınAction<>.

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

• Temsilci türünden örnekler oluşturuyorsanız, kısa söz dizimini kullanın. Sınıfında, temsilci türünü ve eşleşen imzaya sahip bir yöntemi tanımlayın.

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

• Temsilci türünün bir örneğini oluşturun ve çağırın. Aşağıdaki bildirim, sıkıştırılmış söz dizimini gösterir.

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

• Aşağıdaki bildirimde tam söz dizimi kullanılır.

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

try-catch özel durum işlemedeki ve using deyimleri

• Çoğu özel durum işleme için try-catch deyimi kullanın.

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

• C# using deyimini kullanarak kodunuzu basitleştirin. Bloktaki tek kodun yöntemine finally yapılan bir çağrı olduğu bir try-finallyDisposevarsa, bunun yerine deyimini using kullanın.

  Aşağıdaki örnekte, try-finally ifadesi yalnızca Dispose bloğunda finally çağırır.

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

  Aynı şeyi bir using ifadesiyle de yapabilirsiniz.

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

  Ayraç gerektirmeyen yeni using söz dizimini kullanın:

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

&& ve || işleçleri

• Karşılaştırmaları gerçekleştirirken, aşağıdaki örnekte gösterildiği gibi, && yerine & ve || yerine | kullanın.

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

Bölen 0 olduğunda, if deyimindeki ikinci yan tümce çalışma zamanında bir hataya neden olacaktır. Ancak ilk ifade yanlış olduğunda && işleci kısa devre yapar. Yani, ikinci ifadeyi değerlendirmez. & operatorü her ikisini de değerlendirir ve 0 olduğunda bir çalışma zamanı hatası meydana gelir.

new operatör

• Değişken türü, aşağıdaki bildirimlerde gösterildiği gibi nesne türüyle eşleştiğinde nesne örneği oluşturmanın kısa formlarından birini kullanın. Değişken bir arabirim türü veya çalışma zamanı türünün temel sınıfı olduğunda bu form geçerli değildir.

  var firstExample = new ExampleClass();
  

  ExampleClass instance2 = new();
  

  Yukarıdaki bildirimler aşağıdaki bildirime eşdeğerdir.

  ExampleClass secondExample = new ExampleClass();
  

• Aşağıdaki örnekte gösterildiği gibi nesne oluşturmayı basitleştirmek için nesne başlatıcıları kullanın.

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

  Aşağıdaki örnek, önceki örnekle aynı özellikleri ayarlar ancak başlatıcıları kullanmaz.

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

Etkinlik yönetimi

• Daha sonra kaldırmanız gerekmeyen bir olay işleyicisi tanımlamak için lambda ifadesi kullanın:

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

Lambda ifadesi aşağıdaki geleneksel tanımı kısaltır.

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

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

Statik üyeler

Sınıf adını kullanarak statik üyeleri çağırın: ClassName.StaticMember. Bu uygulama, statik erişimi net hale getirerek kodu daha okunabilir hale getirir. Temel sınıfta tanımlanan statik bir üyeyi türetilmiş bir sınıfın adıyla nitelemeyin. Bu kod derlenmiş olsa da kod okunabilirliği yanıltıcıdır ve türetilmiş sınıfa aynı ada sahip statik bir üye eklerseniz kod gelecekte bozulabilir.

LINQ sorguları

• Sorgu değişkenleri için anlamlı adlar kullanın. Aşağıdaki örnekte Seattle'da bulunan müşteriler için kullanılır seattleCustomers .

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

• Anonim türlerin özellik adlarının doğru şekilde Pascal yazımı kullanılarak büyük harfle başlamasından emin olmak için takma adlar kullanın.

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

• Sonuçtaki özellik adları belirsiz olduğunda özellikleri yeniden adlandırın. Örneğin, sorgunuz bir müşteri adı ve dağıtımcı adı döndürürse, sonuçta bir Name biçimi olarak bırakmak yerine, CustomerName müşterinin adı olduğunu ve DistributorName dağıtımcının adı olduğunu netleştirmek için bunları yeniden adlandırın.

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

• Sorgu değişkenlerinin ve aralık değişkenlerinin bildiriminde örtük yazma kullanın. LINQ sorgularında örtük yazmayla ilgili bu kılavuz, örtük olarak yazılan yerel değişkenler için genel kuralları geçersiz kılar. LINQ sorguları genellikle anonim türler oluşturan projeksiyonları kullanır. Diğer sorgu ifadeleri iç içe genel türlerle sonuç oluşturur. Örtük türemiş değişkenler genellikle daha okunabilir.

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

• Önceki örneklerde gösterildiği gibi sorgu yan tümcelerini from yan tümcesi altında hizalayın.

• Daha sonraki sorgu yan tümcelerinin azaltılmış, filtrelenmiş veri kümesinde çalıştığından emin olmak için diğer sorgu yan tümcelerinden önceki yan tümceleri kullanın where .

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

• from yan tümcesi yerine birden çok join yan tümcesiyle iç koleksiyonlara erişin. Örneğin, bir nesne koleksiyonu Student her biri bir test puanı koleksiyonu içerebilir. Aşağıdaki sorgu yürütüldüğünde, 90'ın üzerindeki her puanı ve puanı alan öğrencinin soyadını döndürür.

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

Örtülü olarak belirtilmiş yerel değişkenler

• Yerel değişkenler için değişkenin türü atamanın sağ tarafından açıkça belli olduğunda, örtük yazım kullanın.

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

• Tür atanmanın sağ tarafında belirgin değilse var kullanmayın. Türün yöntem adından açık olduğunu varsaymayın. Değişken türü, bir new işleci, açık bir dönüşüm veya bir değişmez değere atama ise net olarak kabul edilir.

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

• Değişkenin türünü belirtmek için değişken adlarını kullanmayın. Doğru olmayabilir. Bunun yerine türünü kullanarak türü belirtin ve değişkenin anlam bilgilerini belirtmek için değişken adını kullanın. Aşağıdaki örnek, tür için string ve konsoldan okunan bilgilerin anlamını belirtmek için iterations kullanılmalıdır.

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

• var yerine dinamik kelimesini kullanmaktan kaçının. Çalışma zamanı türü çıkarımı istediğinizde kullanın dynamic . Daha fazla bilgi için bkz . Tür dinamik kullanma (C# Programlama Kılavuzu).

• Döngülerin for içinde döngü değişkeni için örtük yazım kullanın.

  Aşağıdaki örnek, bir for deyimde örtük yazma kullanır.

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

• foreach döngülerinde döngü değişkeninin türünü belirlemek için örtük tür belirleme kullanmayın. Çoğu durumda koleksiyondaki öğelerin türü hemen belli olmaz. Koleksiyonun adı, öğelerinin türünü çıkarmak için tek başına güvenilmemelidir.

  Aşağıdaki örnek bir foreach deyimde açık yazma kullanır.

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

• LINQ sorgularındaki sonuç dizileri için örtük tür kullanın. LINQ bölümündeki bölümde birçok LINQ sorgusunun örtük türlerin kullanılması gereken anonim türlerle sonuçlandığı açıklanmaktadır. Diğer sorgular, var'nün daha okunabilir olduğu iç içe geçmiş genel türlere neden olur.

  Not

  Yinelenebilir koleksiyonun bir öğesi türünü yanlışlıkla değiştirmemeye dikkat edin. Örneğin, sorgunun yürütülmesini değiştiren bir System.Linq.IQueryable deyiminde System.Collections.IEnumerable'den foreach geçmek kolaydır.

Örneklerimizden bazıları bir ifadenin doğal türünü açıklar. Bu örneklerin derleyicinin doğal türü seçmesi için kullanması var gerekir. Bu örnekler daha az belirgin olsa da, var kullanımının örnek için gerekli olduğu belirtilmelidir. Metin davranışı açıklamalıdır.

Dosya kapsamlı ad alanı bildirimleri

Çoğu kod dosyası tek bir ad alanı bildirir. Bu nedenle, örneklerimiz dosya kapsamlı ad alanı bildirimlerini kullanmalıdır:

namespace MySampleCode;

using yönergelerini ad alanı bildiriminin dışına yerleştirin

Bir using yönerge bir ad alanı bildiriminin dışında olduğunda, içeri aktarılan ad alanı tam adıdır. Tam ad daha nettir. using yönergesi ad alanının içinde olduğunda, bu ad alanına göre bağıl veya tam nitelikli adı olabilir.

using Azure;

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

WaitUntil sınıfına bir başvuru (doğrudan veya dolaylı) olduğunu varsayarsak.

Şimdi biraz değiştirelim:

namespace CoolStuff.AwesomeFeature
{
    using Azure;

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

Ve bugün derleniyor. Ve yarın. Ancak sonraki hafta içinde önceki (dokunulmamış) kod iki hatayla başarısız oluyor:

- 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

Bu sınıfla ilişkili olarak bir ad alanına eklenen bağımlılıklardan biri .Azureile sonlanıyor:

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

Bir using yönerge bir ad alanına yerleştirildiğinde bağlama duyarlı olur ve ad çözümlemesini karmaşıklaştırır. Bu örnekte, bulduğu ilk ad alanıdır.

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

Yeni bir ad alanı ekleyerek CoolStuff.Azure veya CoolStuff.AwesomeFeature.Azure ile eşleşen bir yapı oluşturmak, genel Azure ad alanından önce eşleşir. global:: değiştiricisini using bildiriminize ekleyerek sorunu çözebilirsiniz. Ancak, bildirimleri using ad alanının dışına yerleştirmek bunun yerine daha kolaydır.

namespace CoolStuff.AwesomeFeature
{
    using global::Azure;

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

Stil yönergeleri

Genel olarak, kod örnekleri için aşağıdaki biçimi kullanın:

• Girintileme için dört boşluk kullanın. Sekmeleri kullanmayın.
• Okunabilirliği geliştirmek için kodu tutarlı bir şekilde hizalayın.
• Belgelerde, özellikle mobil ekranlarda kod okunabilirliğini geliştirmek için satırları 65 karakterle sınırlayın.
• Uzun deyimleri birden çok satıra bölerek netliği ve kullanıcı deneyimini geliştirin.
• Süslü parantezler için "Allman" stilini kullanın: açılış ve kapanış süslü parantezini kendi yeni satırlarına yerleştirin. Ayraçlar geçerli girinti düzeyiyle hizalanmaktadır.
• Gerekirse satır sonları ikili işleçler öncesinde gerçekleşmelidir.

Açıklama stili

• Kısa açıklamalar için tek satırlı açıklamaları (//) kullanın.

• Daha uzun açıklamalar için çok satırlı açıklamalardan (/* */) kaçının.
  Kod örneklerindeki açıklamalar yerelleştirilmemiştir. Bu, koda eklenmiş açıklamaların çevrilmediği anlamına gelir. Daha uzun, açıklayıcı metin, yerelleştirilebilmesi için yardımcı makaleye yerleştirilmelidir.

• Yöntemleri, sınıfları, alanları ve tüm genel üyeleri tanımlamak için XML açıklamalarını kullanın.

• Açıklamayı kod satırının sonuna değil, ayrı bir satıra yerleştirin.

• Açıklama metnine büyük harfle başlayın.

• Açıklama metnini noktayla sonlandırma.

• Aşağıdaki örnekte gösterildiği gibi, açıklama sınırlayıcısı (//) ile açıklama metni arasına bir boşluk ekleyin.

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

Düzen kuralları

İyi düzen, kodunuzun yapısını vurgulama ve kodun daha kolay okunmasını sağlamak için biçimlendirme kullanır. Microsoft örnekleri aşağıdaki konvansiyonlara uygundur:

• Varsayılan Kod Düzenleyicisi ayarlarını kullanın (akıllı girintileme, dört karakterli girintiler, boşluk olarak kaydedilen sekmeler). Daha fazla bilgi için bkz . Seçenekler, Metin Düzenleyicisi, C#, Biçimlendirme.

• Satır başına yalnızca bir deyim yazın.

• Satır başına yalnızca bir bildirim yazın.

• Devamlılık satırları otomatik olarak girintili değilse, bunları bir sekme durağı (dört boşluk) girintileyin.

• Yöntem tanımları ve özellik tanımları arasına en az bir boş satır ekleyin.

• Aşağıdaki kodda gösterildiği gibi ifadedeki yan tümceleri görünür hale getirmek için parantez kullanın.

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

Örneklerin, işleç veya ifadenin önceliğini açıkladığı durumlar istisnadır.

Güvenlik

Güvenli Kodlama Yönergeleri'ndeki yönergeleri izleyin.