C# işleçleri

Tip

Bu makale, en az bir programlama dili bilen ve C# dilini öğrenen geliştiriciler için Temel Bilgiler bölümünün bir parçasıdır. Programlamaya yeni başladıysanız ilk olarak Başlangıç öğreticileri ile başlayın.

Başka bir dilden mi geliyorsunuz? Bu makaledeki işleçlerin çoğu (, , , , , , ==&&>!=<!||karşılaştırma işleçleri ve =) Java, C++ ve JavaScript ile aynı şekilde çalışır. %/*-+ Bu konuya yeni başlayanlar için başlıca sürprizler, tamsayı bölme davranışı, ++/-- için ön ek/son ek ayrımı ve bileşik atamanın yeniden sol taraftaki türe dönüştürülme biçimidir.

Bir işleç, bir veya daha fazla işleneni tek bir değer hâline getirir. C# ifadelerinden ifadeler ve işleç önceliği hakkında zaten bilginiz var; bu makale, her gün kullanacağınız belirli işleçleri daha ayrıntılı bir şekilde açıklar.

Aritmetik operatörler

Beş aritmetik işleç sayısal hesaplamalar yapar.

Operator İsim Example Sonuç
+ Ekleme 10 + 3 13
- Çıkarma 10 - 3 7
* Çarpma 10 * 3 30
/ Bölüm 10 / 3 3
% Bakiye 10 % 3 1 
int apples = 10;
int oranges = 3;

Console.WriteLine(apples + oranges);  // => 13  (addition)
Console.WriteLine(apples - oranges);  // => 7   (subtraction)
Console.WriteLine(apples * oranges);  // => 30  (multiplication)
Console.WriteLine(apples / oranges);  // => 3   (integer division: truncates toward zero)
Console.WriteLine(apples % oranges);  // => 1   (remainder)

// Integer division always truncates toward zero — the fractional part is discarded
int result = 7 / 2;
Console.WriteLine(result); // => 3, not 3.5

// Truncation applies to negative results too: -7 / 2 is -3, not -4
int negResult = -7 / 2;
Console.WriteLine(negResult); // => -3

// To get a decimal result, at least one operand must be a double or float
double precise = 7.0 / 2;
Console.WriteLine(precise); // => 3.5

// Remainder with negative operands: the sign of the result matches the dividend
Console.WriteLine(-7 % 3);  // => -1  (-7 = 3 × -2 + (-1))
Console.WriteLine(7 % -3);  // => 1   ( 7 = -3 × -2 + 1)

Tamsayı bölme sıfıra doğru yuvarlanır. Her iki işlenen de tamsayı olduğunda, / kesirli kısmı atar: 7 / 2, 3 olur; 3.5 değil. Kesme, daha küçük sayıya doğru değil, sıfıra doğrudur: -7 / 2, -3’dir (-4 değil). Ondalık bir sonuç elde etmek için işlenenlerden en az birini kayan noktalı tür yapın: 7.0 / 2 is 3.5. Bu, / ifadesinin her zaman kayan noktalı bir sonuç ürettiği bazı dillerden farklıdır.

Kalan (%), tam sayı bölmesinden sonra kalanı verir: 10 % 3, 10 = 3 × 3 + 1 olduğu için 1'tir. Sabit aralıkta (index % length ) döngü yapma, bölünebilirliği (n % 2 == 0 test etme) ve basamakları ayıklama için kullanışlıdır. Negatif işlenenlerde, sonucun işareti bölünen işaretiyle (sol işlenen) eşleşir: -7 % 3-1 ve 7 % -3 şeklindedir 1.

Tekli operatörler

Tekli işleçler tek bir işlenen üzerinde işlem yapar.

int temperature = 20;
int windChill = -5;

int heatIndex = +temperature;   // unary +: value unchanged (rarely needed)
int coldFactor = -windChill;    // unary -: negates the value → 5

Console.WriteLine(heatIndex);   // => 20
Console.WriteLine(coldFactor);  // => 5

bool isRaining = false;
bool isSunny = !isRaining;     // logical NOT: flips true/false
Console.WriteLine(isSunny);    // => True
  • +x (birli artı) — değeri değişmeden bırakır; nadiren açıkça yazılmıştır ancak geçerlidir.
  • -x (bir eksi) — değeri olumsuzlar.
  • !x (mantıksal DEĞİL) — false değerini false ve true değerini true yapar. Sık sık kullanacaksınız ! : if (!list.Contains(item)).

Artırma ve azaltma

++ 1 ekler ve -- 1'i çıkarır. Her ikisinin de bir ön ek formu ve değerin döndürüldiği farklı bir sonek formu vardır:

int counter = 5;

// Prefix: increment first, then use the new value
int a = ++counter;
Console.WriteLine(a);       // => 6
Console.WriteLine(counter); // => 6

// Postfix: use the current value first, then increment
int b = counter++;
Console.WriteLine(b);       // => 6  (value before increment)
Console.WriteLine(counter); // => 7  (incremented after)

// Decrement works the same way
int score = 10;
Console.WriteLine(score--); // => 10 (current value; score becomes 9)
Console.WriteLine(score);   // => 9
  • Ön ek (++i, --i): önce değişkeni artırır veya azaldırarak yeni değeri döndürür.
  • Sonek (i++, i--): önce geçerli değeri döndürür, ardından değişkeni artırır veya geri dönüştürür.

++ veya --, tek başına bir ifade olarak göründüğünde (daha büyük bir ifadenin parçası olmadığında), önek ve sonek aynı etkiye sahiptir. Ayrım, yalnızca sonuç kullanıldığında önemlidir — örneğin, bir atamada ya da bir yönteme argüman olarak.

İlişkisel işleçler

İlişkisel işleçler iki değeri karşılaştırır ve döndürür bool.

Operator Meaning Example
< Daha Az speed < limit
> Daha büyük speed > limit
<= Küçüktür veya eşittir score <= 100
>= Büyüktür veya eşittir score >= 0 
int speed = 75;
int limit = 60;

Console.WriteLine(speed > limit);   // => True   (greater than)
Console.WriteLine(speed < limit);   // => False  (less than)
Console.WriteLine(speed >= limit);  // => True   (greater than or equal)
Console.WriteLine(speed <= limit);  // => False  (less than or equal)

// Relational operators work on all numeric types and char
// char comparison uses the character's numeric Unicode code point, not alphabetical position
// 'B' (U+0042, value 66) is less than 'A' (U+0041, value 65)? No — 'A' (65) < 'B' (66)
char grade = 'B';
Console.WriteLine(grade >= 'A' && grade <= 'C'); // => True  ('A'=65 <= 'B'=66 <= 'C'=67)

İlişkisel işleçler tüm sayısal türler ve charüzerinde çalışır. için charkarşılaştırma, alfabetik veya etki alanına özgü sıralamaları değil, karakterin sayısal Unicode kod noktası değerini kullanır. Yukarıdaki not örneğinde, 'B', 'A' değerinden büyük veya ona eşittir; çünkü 'A' Unicode değeri 66'ya ve 'B' Unicode değeri 65'e sahiptir — karşılaştırmayı, harf notlarının anlamı değil sayılar belirler.

Eşitlik Operatörleri

== ve != iki değerin eşit olup olmadığını denetleyin. != , true işlenenlerin eşit olmadığı ve false eşit oldukları zamanlardır.

int expected = 42;
int actual = 42;

Console.WriteLine(actual == expected);  // => True   (values are equal)
Console.WriteLine(actual != expected);  // => False  (true when values are not equal)

string name = "Alice";
Console.WriteLine(name == "Alice");  // => True   (string content matches)
Console.WriteLine(name == "alice");  // => False  (case-sensitive)

int x = 5;
Console.WriteLine(x == 10);  // => False

Sayısal türler ve string için eşitlik, değerleri sınar. Referans türleri için varsayılan olarak kimlik karşılaştırması kullanılır (iki değişkenin aynı nesneyi gösterip göstermediği); ancak string ve record dahil olmak üzere birçok tür, içerikleri karşılaştırmak için bu davranışı geçersiz kılar. Tam resim (eşitliğin değer türleri, başvuru türleri, kayıtlar ve yapılar arasında nasıl çalıştığı) için bkz. Eşitlik karşılaştırmaları.

Note

C#'ta === işleci yoktur. === yazmak derleme zamanında hataya neden olur:

// This does not compile — C# has no === operator
bool same = (x === 10);

JavaScript'ten geliyorsanız, değer karşılaştırması için kullanın == (C# == zaten ilkel türler ve dizeler için değere göre karşılaştırır). Bununla ilgili yaygın bir hata, amaçlanan == (eşitlik karşılaştırması) yerine yanlışlıkla = (atama) yazmaktır. Derleyici en yaygın biçimleri yakalar, ancak if içeren tüm = koşullarını yeniden kontrol edin.

Koşullu mantıksal işleçler

&& (AND) ve || (OR) ifadeleri birleştirir bool .

int age = 20;
bool hasTicket = true;

// && (AND): both sides must be true
bool canEnter = age >= 18 && hasTicket;
Console.WriteLine(canEnter); // => True

// || (OR): at least one side must be true
bool freeEntry = age < 5 || age >= 65;
Console.WriteLine(freeEntry); // => False

// Short-circuit: right side is skipped when the result is already determined
// Here, items.Count is never called if items is null
List<string>? items = null;
bool hasItems = items != null && items.Count > 0;
Console.WriteLine(hasItems); // => False  (short-circuits; no NullReferenceException)

Her iki işleç de kısa devre yapar: sonuç zaten belirlenmişse sağ işleneni değerlendirmezler.

  • &&, sol taraf false olur olmaz false döndürür. Sağ taraf hiçbir zaman değerlendirilmez.
  • ||, sol taraf true olur olmaz true döndürür. Sağ taraf hiçbir zaman değerlendirilmez.

Kısa devre davranışının pratik bir avantajı vardır: Yukarıdaki örnekte gösterildiği gibi, sol tarafta null denetimle sağ taraftaki bir işlemi güvenli bir şekilde koruyabilirsiniz. items null ise, && orada durur — items.Count hiçbir zaman çağrılmaz, dolayısıyla NullReferenceException fırlatılmaz.

Koşullu işleç ?:

Koşullu işleç ( üçüncül işleç olarak da adlandırılır) bir koşula göre iki ifadeden birini değerlendirir:

condition ? value-when-true : value-when-false

int temperature2 = 35;

// condition ? value-when-true : value-when-false
string weather = temperature2 > 30 ? "hot" : "comfortable";
Console.WriteLine(weather); // => hot

// Only the matching branch evaluates — the other branch is never run
int divisor = 0;
// The division 10 / divisor is never evaluated because divisor == 0 is true
int safe = divisor == 0 ? -1 : 10 / divisor;
Console.WriteLine(safe); // => -1

İşleç ?: her zaman tam olarak bir dal değerlendirir; koşulla eşleşmeyen taraf hiçbir zaman değerlendirilmez. Bu, koşul düzgün bir şekilde koruma sağladığı sürece diğer girişler için başarısız olacak bir ifadenin bir tarafında kullanılmasını güvenli hale getirir.

Basit, satır içi seçenekler için kullanın ?: . Çok yönlü koşullar veya kod blokları için deyim if/else genellikle daha nettir.

Atama işleçleri

Basit atama işleci = bir değeri bir değişkende depolar:

int level = 1;  // declaration + initialization
level = 5;      // reassignment

C# dilinde atama sağ ilişkilendiricidir, yani a = b = c = 0 sağdan sola doğru değerlendirir: c alır 0, sonra b alır 0ve alır a0.

Bileşik atama

Bileşik atama işleçleri, ikili işlemi atamayla birleştirir:

Operator Eşdeğer
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y 
int level = 1;
level = 5;          // simple assignment: replaces the value
Console.WriteLine(level); // => 5

// Compound assignment: short form of binary operation + assignment
int hp = 100;
hp += 20;   // same as: hp = hp + 20
Console.WriteLine(hp); // => 120
hp -= 10;   // same as: hp = hp - 10
Console.WriteLine(hp); // => 110
hp *= 2;    // same as: hp = hp * 2
Console.WriteLine(hp); // => 220
hp /= 3;    // same as: hp = hp / 3 (integer division)
Console.WriteLine(hp); // => 73
hp %= 7;    // same as: hp = hp % 7
Console.WriteLine(hp); // => 3

Bileşik atama yalnızca bir kısaltma değildir. Sol tarafı tam olarak bir kez değerlendirir ve ardından sonucu yeniden sol taraftaki türe dönüştürür. Bu durum, sol tarafta yan etkiler olduğunda (örneğin bir dizi indisleyicisi) önemlidir ve byte türündeki bir değişken üzerinde yapılan bileşik atamanın açık bir tür dönüştürme olmadan derlenmesinin, genişletilmiş biçimin ise derlenmemesinin nedeni budur:

// Assignment is right-associative: evaluated right to left
int a2, b2, c2;
a2 = b2 = c2 = 0;     // c2 = 0 first, then b2 = 0, then a2 = 0
Console.WriteLine($"{a2} {b2} {c2}"); // => 0 0 0

// Compound assignment evaluates the left side once and converts back to the LHS type
byte small = 200;
small += 10;  // equivalent to: small = (byte)(small + 10); result is 210
Console.WriteLine(small); // => 210

small += 10 derlenir, çünkü derleyici daraltıcı dönüşümü otomatik olarak ekler — sonuç olan 210, 0–255 arasındaki byte aralığına sığar. small = small + 10, aritmetik her iki işleneni de (byte)'ye yükselttiği için açık bir int tür dönüştürmesi gerektirir.

Diğer C# işleçleri

Bu makale, günlük kodda en çok karşılaşabileceğiniz işleçleri kapsar. C# dili, belirli senaryolarda yararlı olan daha fazla işleç içerir:

  • Shift işleçleri (<<, >>, >>>) — Bir tamsayı değerinin bitlerini belirtilen sayıda konumla sola veya sağa kaydırın. Bit düzeyinde ve tamsayı mantıksal işleçleri (&, |, ^, ~) — tamsayı değerlerini bir kerede bir bit birleştirin veya tersine çevirin; bayraklarda, maskelerde ve alt düzey kodda yararlıdır: Bit düzeyinde ve shift işleçleri
  • checked ve unchecked — tamsayı taşmasının bir özel durum fırlatıp fırlatmayacağını (checked) veya sessizce sarmalanıp sarmalanmayacağını (unchecked) denetler: Checked ve unchecked
  • Null işleçler (??, ??=, ?., ?[]) — null değerlerini varsayılanlar sağlayarak veya üye erişimini kısa devreye alarak güvenli bir şekilde işleyin: Null işleçler
  • Tür testi ve dönüştürme işleçleri (is, as, typeof, atama (T)) — bir değerin çalışma zamanı türünü denetleyin veya dönüştürün: Tür testi ve atama işleçleri
  • Aralık ve dizin işleçleri (.., ^) — dizileri ve aralıkları dilimleme için aralıklar ve son göreli dizinler oluşturur: Üye erişimi ve null koşullu işleçler
  • Ayrıştırma ataması — bir demeti veya türü tek bir ifadede ayrı değişkenlere ayırma: Demetlerin ve diğer türlerin ayrıştırılması

Ayrıca bakınız

  • Last updated on