C# Operatörler: Aritmetik, Mod Alma, Mantıksal, Bitsel ve Öncelik

Bir operatör bir, iki ya da üç işlenen alır ve bir değer üretir: a + b, !done, x ?? fallback. C#'ın operatörleri C, Java ve JavaScript'inkilere yakındır, ama birkaçı yeni başlayanları şaşırtan biçimlerde davranır; özellikle tamsayı bölmesi ve %'nin işareti.

Aritmetik operatörler

+, -, *, / ve % her sayısal tipte çalışır. Sonucun tipi işlenenleri izler: iki int değeri bir int, bir int ile bir double bir double üretir.

using System;

class Program
{
    static void Main()
    {
        int apples = 17, boxes = 5;

        Console.WriteLine(apples + boxes);   // 22
        Console.WriteLine(apples - boxes);   // 12
        Console.WriteLine(apples * boxes);   // 85
        Console.WriteLine(apples / boxes);   // 3: integer division
        Console.WriteLine(apples % boxes);   // 2: remainder

        Console.WriteLine(apples / 5.0);            // 3.4
        Console.WriteLine((double)apples / boxes);  // 3.4
        Console.WriteLine((double)(apples / boxes)); // 3: divided first, then converted
        Console.WriteLine(apples / 5m);             // 3.4 as decimal
    }
}

Çıktı:

22
12
85
3
2
3.4
3.4
3
3.4

Tamsayı bölmesi sıfıra doğru keser. 17 / 5 3, -17 / 5 ise -3'tür. Bu çok yaygın bir hataya yol açar: int percent = done / total * 100; done < total olduğunda her zaman 0'dır, çünkü done / total zaten 0'dır. Önce çarpın (done * 100 / total) ya da double olarak bölün.

Bir tamsayıyı ya da decimal'i sıfıra bölmek DivideByZeroException fırlatır. Bir double'ı sıfıra bölmek istisna fırlatmaz; sonsuz ya da 0.0 / 0.0 için NaN üretir:

using System;

class Program
{
    static void Main()
    {
        double ratio = 5.0 / 0;
        double undefined = 0.0 / 0;
        Console.WriteLine(double.IsPositiveInfinity(ratio));
        Console.WriteLine(double.IsNaN(undefined));
        Console.WriteLine(undefined == undefined);   // NaN never equals anything

        int zero = 0;
        try
        {
            Console.WriteLine(10 / zero);
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("DivideByZeroException");
        }
    }
}

Çıktı:

True
True
False
DivideByZeroException

Mod operatörü ve negatif sayılar

% bölmenin kalanını döndürür ve sonucu sol işlenenin işaretini alır. Bu, pozitif bir bölen için her zaman negatif olmayan Python'dan ve matematikteki "mod"dan farklıdır:

using System;

class Program
{
    static int Mod(int a, int n)
    {
        return ((a % n) + n) % n;   // always in 0..n-1
    }

    static void Main()
    {
        Console.WriteLine(7 % 3);     // 1
        Console.WriteLine(-7 % 3);    // -1
        Console.WriteLine(7 % -3);    // 1
        Console.WriteLine(Mod(-7, 3)); // 2

        // Common uses:
        int n = 42;
        Console.WriteLine(n % 2 == 0 ? "even" : "odd");

        int totalSeconds = 3725;
        Console.WriteLine($"{totalSeconds / 60} min {totalSeconds % 60} s");

        string[] days = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
        int today = 5, offset = -9;
        Console.WriteLine(days[Mod(today + offset, 7)]);  // wraps backwards safely

        Console.WriteLine(7.5 % 2);   // works on double: 1.5
    }
}

Çıktı:

1
-1
1
2
even
62 min 5 s
Thu
1.5

Sol taraf negatif olabiliyorsa ve sonuç bir indeksse Mod yardımcısını kullanın: days[(today + offset) % 7] negatif bir toplam için IndexOutOfRangeException fırlatırdı. Tek sayı testi de aynı tuzağa sahiptir: n % 2 == 1 negatif tek sayılar için false'tur; n % 2 != 0 testini yapın.

Atama, bileşik atama ve artırma

= atar. Bileşik biçimler +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= bir işlemi atamayla birleştirir. ++ ve -- 1 ekler ya da çıkarır ve döndürdükleri değerde farklılaşan önek ve sonek biçimlerinde gelir:

using System;

class Program
{
    static void Main()
    {
        int stock = 10;
        stock -= 3;          // stock = stock - 3
        stock *= 2;          // stock = stock * 2
        Console.WriteLine(stock);   // 14

        string log = "start";
        log += ", step";     // += concatenates strings
        Console.WriteLine(log);

        int i = 5;
        int a = i++;   // a gets 5, then i becomes 6
        int b = ++i;   // i becomes 7, then b gets 7
        Console.WriteLine($"a={a} b={b} i={i}");

        byte level = 250;
        level += 10;   // compiles: compound assignment casts back to byte (and wraps)
        Console.WriteLine(level);
    }
}

Çıktı:

14
start, step
a=5 b=7 i=7
4

byte örneği bir tuhaflığı gösterir: level = level + 10; derlenmez, çünkü byte + int bir int'tir; ama level += 10; derlenir, çünkü bileşik atama değişkenin tipine örtük bir cast içerir. Bu cast taşmada başa sarar (250 + 10, 4 olur).

Karşılaştırma ve mantıksal operatörler

Karşılaştırma operatörleri (==, !=, <, >, <=, >=) bir bool döndürür. String'ler için == referansları değil metni karşılaştırır. Mantıksal operatörler ! (değil), && (ve), || (veya) ve ^ (özel veya) şeklindedir.

using System;

class User
{
    public string Name;
    public bool IsActive;
}

class Program
{
    static bool Check(string label, bool result)
    {
        Console.WriteLine($"  evaluated {label}");
        return result;
    }

    static void Main()
    {
        Console.WriteLine(3 < 5 && "abc" == "ab" + "c");

        User user = null;
        // Safe: && stops at the first false, so user.IsActive is never read.
        if (user != null && user.IsActive)
            Console.WriteLine("active");
        else
            Console.WriteLine("no active user");

        Console.WriteLine("with ||:");
        bool r1 = Check("A", true) || Check("B", true);   // B is skipped

        Console.WriteLine("with |:");
        bool r2 = Check("A", true) | Check("B", true);    // both run

        Console.WriteLine(true ^ false);   // exactly one is true
    }
}

Çıktı:

True
no active user
with ||:
  evaluated A
with |:
  evaluated A
  evaluated B
True

&& ve || kısa devre yapar: sağ işlenen yalnızca sonucu değiştirebilecekse çalışır. user != null && user.IsActive ifadesini güvenli yapan budur. Boolean'larda tek & ve | her zaman iki tarafı da değerlendirir; bu bir koşulda nadiren istenen şeydir.

Bitsel ve kaydırma operatörleri

Tamsayı tiplerinde &, |, ^ ve ~ tek tek bitler üzerinde çalışır, << ve >> onları kaydırır. Bayraklar, maskeler, hash hesaplama ve düşük seviye protokoller için kullanılırlar:

using System;

class Program
{
    const int Read = 1;     // 0001
    const int Write = 2;    // 0010
    const int Delete = 4;   // 0100

    static void Main()
    {
        int permissions = Read | Write;              // set two flags
        Console.WriteLine(permissions);                        // 3
        Console.WriteLine((permissions & Write) != 0);          // has Write?
        Console.WriteLine((permissions & Delete) != 0);         // has Delete?

        permissions |= Delete;                       // add a flag
        permissions &= ~Write;                       // remove a flag
        Console.WriteLine(Convert.ToString(permissions, 2));    // 101

        Console.WriteLine(1 << 10);                  // 1024
        Console.WriteLine(1000 >> 3);                // 125 (divide by 8)
        Console.WriteLine(6 ^ 3);                    // 110 xor 011 = 101 = 5
        Console.WriteLine(~0);                       // all bits set: -1
    }
}

Çıktı:

3
True
False
101
1024
125
5
-1

Adlandırılmış bayrak kümeleri için [Flags] özniteliğine sahip bir enum, tamsayı sabitlerinden daha anlaşılırdır ve HasFlag bir maskeden daha iyi okunur. C# 11, negatif sayılar için bile sıfırlarla dolduran işaretsiz sağa kaydırma >>>'ı ekledi.

Null operatörleri

null olabilen değerlerle çalışmak için üç operatör vardır:

using System;

class Program
{
    static void Main()
    {
        string nickname = null;
        string display = nickname ?? "Guest";         // fallback when null
        Console.WriteLine(display);

        Console.WriteLine(nickname?.Length);          // null, not an exception
        int length = nickname?.Length ?? 0;
        Console.WriteLine(length);

        int? discount = null;
        Console.WriteLine(discount ?? 5);
    }
}

Çıktı:

Guest

0
5

a ?? b, null değilse a'yı, null ise b'yi döndürür. a?.Member, a null olduğunda istisna fırlatmak yerine null döndürür. C# 8, yalnızca a null olduğunda a'ya b'yi atayan a ??= b'yi ekledi. Bunlar nullable tipler sayfasında ayrıntılı ele alınır.

Operatör önceliği

Bir ifade operatörleri karıştırdığında üst satırlar daha sıkı bağlanır. Aynı satırdaki operatörler soldan sağa gruplanır; atama, ?? ve ?: ise sağdan sola gruplanır. (İşlenenlerin kendileri her zaman soldan sağa değerlendirilir.)

Bilmeye değer iki sonuç: a + b * c önce çarpar ve x & mask == 0 önce karşılaştırır (==, &'den daha sıkı bağlanır), yani x & (mask == 0) anlamına gelir ve tamsayılar için derlenmez. (x & mask) == 0 yazın. Parantezlerin hiçbir maliyeti yoktur ve niyeti açıkça gösterir.

Operatör aşırı yükleme

Kendi tipleriniz operatörlerin ne anlama geldiğini tanımlayabilir. decimal, DateTime ve TimeSpan'in + ve <'yi desteklemesi böyledir:

using System;

struct Money
{
    public readonly decimal Amount;
    public Money(decimal amount) { Amount = amount; }

    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public static Money operator *(Money a, int n) => new Money(a.Amount * n);
    public static bool operator >(Money a, Money b) => a.Amount > b.Amount;
    public static bool operator <(Money a, Money b) => a.Amount < b.Amount;

    public override string ToString() => Amount.ToString("F2");
}

class Program
{
    static void Main()
    {
        var shirt = new Money(19.99m);
        var socks = new Money(4.50m);
        Money total = shirt + socks * 3;
        Console.WriteLine(total);
        Console.WriteLine(total > new Money(30m));
    }
}

Çıktı:

33.49
True

Operatörler public static olmalıdır ve bazıları zorunlu çiftler halinde gelir: < tanımlamak > gerektirir, == de != gerektirir. == tanımlandığında derleyici, eşleşecek şekilde Equals ve GetHashCode'u override edene kadar uyarı da verir. Operatörleri yalnızca anlamın açık olduğu yerlerde aşırı yükleyin; sayılar, vektörler ve para gibi.