Çalıştırılabilir C# Dokümanları: Değişkenler

Q: C#'ta var nedir?

var derleyiciye yerel bir değişkenin tipini başlatıldığı değerden çıkarmasını söyler: var count = 5; bir int bildirir. Değişken yine de statik tiplidir ve sonradan bir string tutamaz. var yalnızca aynı ifadede başlatılan yerel değişkenler için çalışır.

Q: C#'ta const ile readonly arasındaki fark nedir?

const bir derleme zamanı sabitidir: değeri derleme sırasında bilinmelidir (sayılar, string'ler, bool, null), örtük olarak statiktir ve değer onu kullanan her yere kopyalanır. readonly bir alan ise çalışma zamanında, bildiriminde ya da bir constructor'da bir kez ayarlanır, her tipi tutabilir ve nesneden nesneye farklı olabilir.

Q: const yerine ne zaman static readonly kullanmalıyım?

Derleme zamanı sabiti olamayan paylaşılan bir değer için (DateTime, bir dizi ya da bir nesne gibi) ya da bir kütüphanenin sürümleri arasında değişebilecek public bir değer için static readonly kullanın. const değerleri çağıran assembly'lere kopyalandığından, public bir const'u değiştirmek onu kullanan her assembly'nin yeniden derlenmesini gerektirir.

Değişken, sabit bir tipi olan adlandırılmış bir depolama yeridir. C#'ta onu bir tip ve bir adla bildirirsiniz ve isterseniz aynı ifadede ona bir değer verirsiniz. Tip sonradan asla değişmez: bir int değişkeni var olduğu sürece tam sayılar tutar.

using System;

class Program
{
    static void Main()
    {
        string customer = "Priya";   // declare and initialize
        int quantity;                // declare only
        quantity = 3;                // assign later
        decimal unitPrice = 4.25m;
        bool isMember = true;

        quantity = quantity + 2;     // reassign
        decimal total = quantity * unitPrice;
        if (isMember) total -= 1.00m;

        Console.WriteLine($"{customer} bought {quantity} items for {total:F2}");

        int apples = 4, pears = 6;   // several of the same type
        Console.WriteLine(apples + pears);
    }
}

Çıktı:

Priya bought 5 items for 20.25
10

Yanlış tipte bir değer atamak derleme hatasıdır: quantity = "five"; CS0029 (cannot implicitly convert type 'string' to 'int') ile başarısız olur. Tipler arası dönüşüm açıktır; bkz. tip dönüşümü.

var: tipi derleyiciye çıkartmak

var, tipi başlatıcısından çıkarılan yerel bir değişken bildirir. Dinamik tipleme değildir: tip, tıpkı açıkça yazmışsınız gibi derleme zamanında sabitlenir.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var name = "Oscar";          // string
        var age = 34;                // int
        var price = 19.99m;          // decimal
        var ratio = 0.75;            // double
        var tags = new List<string> { "new", "sale" };

        Console.WriteLine(name.GetType().Name);
        Console.WriteLine(age.GetType().Name);
        Console.WriteLine(price.GetType().Name);
        Console.WriteLine(ratio.GetType().Name);
        Console.WriteLine(tags.GetType().Name);

        // age = "old";  // error CS0029: age is an int, forever
    }
}

Çıktı:

String
Int32
Decimal
Double
List`1

var'ın üç kuralı vardır. Yalnızca yerel değişkenler için çalışır (alanlar ya da parametreler için değil). Değişken bildirimde başlatılmalıdır: var x; CS0818 hatasıdır, "Implicitly-typed variables must be initialized". Ve başlatıcının bir tipi olmalıdır: var nothing = null; derlenmez, çünkü tek başına null'ın tipi yoktur.

Ne zaman kullanılacağı ekip stiline bağlıdır. Olağan kural, tip sağ taraftan belliyse var kullanmak, değilse tipi yazmaktır:

var orders = new List<Order>();         // obvious: var is fine
var reader = new StreamReader(path);    // obvious
decimal discount = CalculateDiscount(); // not obvious: name the type
int count = items.Count();              // makes the intent clear

İnce bir tuzak: var total = 0; total'ı bir int yapar, bu yüzden sonradan ona 2.5 eklemek başarısız olur; var price = 10; da bir decimal değil int'tir. Literal'in tipi istediğiniz tip değilse tipi yazın ya da bir son ek ekleyin (10m, 0.0).

Kapsam

Yerel bir değişken, bildiriminden bildirildiği { } bloğunun sonuna kadar var olur. Bir döngü başlığında ya da bir if gövdesinde bildirilen değişkenler ondan sonra görünmez.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 82, 91, 67 };
        int sum = 0;                         // visible in the whole of Main

        for (int i = 0; i < scores.Length; i++)   // i: only inside the loop
        {
            int doubled = scores[i] * 2;     // doubled: only inside the loop body
            sum += scores[i];
        }
        // Console.WriteLine(i);        // error CS0103: i does not exist here

        if (sum > 200)
        {
            string label = "high";
            Console.WriteLine(label);
        }
        Console.WriteLine(sum);
    }
}

Çıktı:

high
240

C ve C++'tan farklı olarak C#, iç bir bloğun çevreleyen bir bloktakiyle aynı adda yerel bir değişken bildirmesine izin vermez (CS0136 hatası): bir ad bir metot boyunca tek bir anlama gelmelidir. Kardeş iki blok bir adı yeniden kullanabilir; her biri i bildiren iki ayrı for döngüsü gibi.

Kesin atama

Yerel değişkenlerin varsayılan değeri yoktur. Derleyici metottaki her yolu izler ve bir değişken atanmadan önce okunabilecekse derlemeyi reddeder:

int discount;
if (isMember)
{
    discount = 10;
}
Console.WriteLine(discount);
// error CS0165: Use of unassigned local variable 'discount'

Bunu bildirimde başlatarak (int discount = 0;) ya da her dalda atama yaparak (else ekleyin) düzeltin. Alanlar ve dizi elemanları farklıdır: otomatik olarak tiplerinin varsayılan değerine (0, false, null) ayarlanırlar.

const: derleme zamanı sabitleri

const, derleme zamanında sabitlenen bir değerdir. Sabit bir ifadeyle (bir literal, başka bir const ya da bunlar üzerindeki aritmetik) başlatılmalıdır ve yalnızca bir sayı, char, bool, string, enum ya da null olabilir.

using System;

class Pricing
{
    public const decimal VatRate = 0.20m;
    public const int MaxItems = 50;
    public const string Currency = "EUR";
    public const string Label = "Price in " + Currency; // consts can combine
}

class Program
{
    static void Main()
    {
        const int Days = 7;          // local constants work too
        decimal net = 100m;

        Console.WriteLine(Pricing.Label);
        Console.WriteLine($"{net * (1 + Pricing.VatRate):F2} {Pricing.Currency}");
        Console.WriteLine(Pricing.MaxItems * Days);
        // Pricing.MaxItems = 60;   // error: cannot assign to a constant
    }
}

Çıktı:

Price in EUR
120.00 EUR
350

Bir const alan örtük olarak static'tir, bu yüzden tip adı üzerinden erişilir (Pricing.VatRate) ve static const yazmak bir hatadır. Derleyici değeri onu kullanan her yere kopyalar; const'ların çalışma zamanında hiçbir maliyeti olmamasının nedeni budur ve aynı zamanda bir kütüphanedeki public bir const'un asla değişmeyecek bir değer (bir haftadaki gün sayısı gibi) olması gerekmesinin de nedeni budur.

readonly ve static readonly

Bir readonly alana yalnızca bildiriminde ya da sınıfının bir constructor'ında değer atanabilir. Nesne oluşturulduktan sonra değişemez. const'tan farklı olarak değeri çalışma zamanında hesaplanır, her tipte olabilir ve nesneler arasında farklı olabilir.

using System;

class Account
{
    public readonly string Id;                    // set once per object
    public readonly DateTime OpenedOn;
    public static readonly DateTime Launch = new DateTime(2020, 1, 15);
    public static readonly string[] Plans = { "free", "pro" };

    public Account(string id, DateTime openedOn)
    {
        Id = id;                                  // allowed: in the constructor
        OpenedOn = openedOn;
    }

    public void Rename(string newId)
    {
        // Id = newId;  // error CS0191: readonly field outside the constructor
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("ACC-17", new DateTime(2024, 5, 2));
        Console.WriteLine($"{a.Id} opened {a.OpenedOn:yyyy-MM-dd}");
        Console.WriteLine($"Launch: {Account.Launch:yyyy-MM-dd}");

        Account.Plans[0] = "basic";   // allowed: the array itself is not readonly
        Console.WriteLine(string.Join(", ", Account.Plans));
    }
}

Çıktı:

ACC-17 opened 2024-05-02
Launch: 2020-01-15
basic, pro

Son satırlar yaygın yanlış anlamayı gösterir: readonly işaret ettiği nesneyi değil alanı korur. Plans her zaman aynı diziye başvuracaktır, ama dizinin elemanları yine de değişebilir. Gerçekten değiştirilemez koleksiyonlar için ReadOnlyCollection<T> ya da ImmutableArray<T> kullanın.

Üçünün özeti:

	`const`	`readonly`	`static readonly`
Değerin bilindiği an	Derleme zamanı	Çalışma zamanı	Çalışma zamanı
İzin verilen tipler	Sayılar, `char`, `bool`, `string`, enum'lar, `null`	Hepsi	Hepsi
Ayarlandığı yer	Yalnızca bildirim	Bildirim ya da constructor	Bildirim ya da statik constructor
Nesne başına mı paylaşılan mı	Paylaşılan (örtük olarak statik)	Nesne başına	Paylaşılan
Yerel değişkenler	Evet (`const int x = 1;`)	Hayır	Hayır

Adlandırma kuralları

C# adları büyük/küçük harfe duyarlıdır (total ve Total farklı değişkenlerdir) ve bir harf ya da alt çizgiyle başlamalıdır. Neredeyse tüm C# kodunun izlediği Microsoft kuralları:

Yerel değişkenler ve parametreler: camelCase (orderCount, unitPrice).
Sabitler, property'ler, metotlar, sınıflar ve public alanlar: PascalCase (MaxItems, VatRate).
Private alanlar: başta alt çizgiyle _camelCase (_balance), .NET kodunda yaygın bir kural.
Boolean'lar soru gibi okunur: isActive, hasDiscount, canRetry.
Kısaltmalardan ve Macar önek sisteminden (strName, iCount) kaçının.

Bir C# anahtar kelimesi ad olamaz, önüne @ koymadıkça: var @class = "5B"; geçerlidir; bu bazen üretilen kod ya da JSON alan adları için işe yarar.

Değer takası ve çoklu atama

C# 7'den beri tuple'lar tek bir ifadede birkaç değişkene atama yapmanızı sağlar; bu da tek satırlık bir takas verir:

using System;

class Program
{
    static void Main()
    {
        int first = 10, second = 20;
        (first, second) = (second, first);
        Console.WriteLine($"{first} {second}");

        var (city, population) = ("Lisbon", 545000);
        Console.WriteLine($"{city}: {population:N0}");
    }
}

Çıktı:

20 10
Lisbon: 545,000

İkinci biçim deconstruction'dır: bir tuple'dan city'yi string, population'ı int olarak bildirir. Daha fazlası tuple'lar sayfasında.

Sıkça Sorulan Sorular

C#'ta var nedir?

var derleyiciye yerel bir değişkenin tipini başlatıldığı değerden çıkarmasını söyler: var count = 5; bir int bildirir. Değişken yine de statik tiplidir ve sonradan bir string tutamaz. var yalnızca aynı ifadede başlatılan yerel değişkenler için çalışır.

C#'ta const ile readonly arasındaki fark nedir?

const bir derleme zamanı sabitidir: değeri derleme sırasında bilinmelidir (sayılar, string'ler, bool, null), örtük olarak statiktir ve değer onu kullanan her yere kopyalanır. readonly bir alan ise çalışma zamanında, bildiriminde ya da bir constructor'da bir kez ayarlanır, her tipi tutabilir ve nesneden nesneye farklı olabilir.

const yerine ne zaman static readonly kullanmalıyım?

Derleme zamanı sabiti olamayan paylaşılan bir değer için (DateTime, bir dizi ya da bir nesne gibi) ya da bir kütüphanenin sürümleri arasında değişebilecek public bir değer için static readonly kullanın. const değerleri çağıran assembly'lere kopyalandığından, public bir const'u değiştirmek onu kullanan her assembly'nin yeniden derlenmesini gerektirir.

C#'ta "use of unassigned local variable" ne demek?

CS0165 hatası: derleyici, yerel bir değişkenin kendisine herhangi bir değer atanmadan önce okunduğu bir yol buldu. C#'ta yerel değişkenlerin varsayılan değeri yoktur. Değişkeni bildirirken başlatın ya da kullanılmadan önce if/switch'in her dalının ona değer atadığından emin olun.

C#'ta var mı kullanmalıyım, açık tip mi?

İkisi de uygundur; ekipler bir stil seçer. Yaygın bir kural, tip sağ taraftan belliyse var kullanmak (var list = new List<string>();), değilse tipi yazmaktır (decimal total = GetTotal();). .NET runtime kod tabanı kabaca bu kuralı izler.

İlgili kavramlar