Sayı Tutma Oyunu Yapma


basla:
            Console.Title = "Sayı Bulma Oyunu";
            Console.Write("Bilgisayarın Belirledigi Sayi 0-2000 Arasındadır...\n");  
            Random rnd = new Random();
            int tutulansayi = rnd.Next(0, 2000);
            int tahmin;
            Console.Write("Tahmininizi Giriniz  :");
             do
             {
               
                 tahmin=Convert.ToInt16(Console.ReadLine());
                 break;

                 if (tahmin>tutulansayi)
                 { Console.Clear();
                 Console.Write("Daha Kücük Bir Sayi Giriniz");
                 break;
                 }
                 else if (tahmin < tutulansayi)
                 {
                     Console.Clear();
                     Console.Write("Daha Büyük Bir Sayi Giriniz");
                   
                 }
                 else
                 {
                     Console.Clear();
                     Console.Write("Tutulan sayi {0}'di", tutulansayi);
                     Console.Write("Tebrikler dogru tahmin");
                 }


             }while(tahmin!=tutulansayi);
             Console.Write("Tekrar Oynamak İstermisiniz (E/H)");

             char cevap = Console.ReadKey().KeyChar;
             if (cevap == 'e'||cevap=='E')

         

                 goto basla;
Devamını Oku

Koşul İfadeleri (if else, switch case) ve Döngüler(for, do while, while)


Koşul İfadeleri ve Akış Kontrolü
Koşul ifadeleri ve akış kontrolleri programlama dillerinde her zaman en önemli yeri tutmaktadır. Yazdığımız uygulamanın hangi koşulda nasıl davranacağını belirterek bir akış kontrolü oluşturabilmek için koşul ifadelerini iyi bilmemiz gerekir. Tüm programlama dillerinde olduğu gibi en temel koşul ifadesi if else bloklarıdır.
if…else Bloğu
if…else yapısı uygulamalarımızda sık sık kullandığımız ve kullanmak zorunda olduğumuz bir yapıdır. Programlamayı if…else blokları olmadan düşünmek imkansızdır. Koşul ifadeleri uygulamalarımızda bir karar verme mekanizması gibi davranır.
if(bool bir ifade)
   Doğru ise
else
   Yanlış ise

if…else ifadesinin yapısı yukarıdaki gibidir. Bir durum if içerisinde karşılaştırılır eğer koşul doğru ise if altına yazdığımız blok kod veya tek bir satır kod çalışır, koşul yanlış ise else bloğuna tanımladığımız kod kısmı çalışır. Else kısmını yazmak zorunda değiliz. Eğer yazmaksak ve koşulda yanlış ise if bloğu içine giremeyeceği için herhangi bir işlem yapılmadan bir sonraki kısma geçerek kodumuz akmaya devam eder.
if (ad == "Sabri")
    Console.WriteLine("Merhaba Sabri. Ne zamandır gözükmüyodun...");

Yukarıda göründüğü gibi else yazmadan da karşılaştırma yapabiliriz. Eğer ad Sabri ise if içindeki kod çalışır değilse bir sonraki aşamaya geçerek kodumuz çalışmaya devam eder. Yukarıdaki kodun else ile kullanımı ise aşağıdaki gibidir.
if (ad == "Sabri")
    Console.WriteLine("Merhaba Sabri. Ne zamandır gözükmüyodun...");
else
    Console.WriteLine("Sende Kimsin...");

Eğer if ve else blokları içinde birden fazla satır kod yazmak istiyorsanız { }ifadelerini kullanmanız gerekir.
if (ad == "Sabri")
{
    gelenKisi = ad;
    Console.WriteLine("Merhaba Sabri. Ne zamandır gözükmüyodun...");
}
else
{
    gelenKisi = "İzinsiz";
}

Her zaman {} parantezlerini kullanmanızı tavsiye ederim. Kodunuzun okunurluluğunu arttırdığı gibi hata yapmanızı da engeller.
if ifadesini isterseniz else bloklarında da kullanabilirsiniz. Böylece karşılaştırma kriterinizi genişletmiş olursunuz.
if (ad == "Sabri")
{
    gelenKisi = ad;
    Console.WriteLine("Merhaba Sabri. Ne zamandır gözükmüyodun...");
}
else if (ad == "Metin")
{
    gelenKisi = ad;
    Console.WriteLine("Vaaaay Sen Ha...");
}
else
{
    gelenKisi = "İzinsiz";
    Console.WriteLine("Sende Kimsin...");
}

if… else bloklarını iç içe de kullanabilirsiniz.
if (yas > 25)
{
    if (yas == 26)
    {
        Console.WriteLine("Sınırda Geziyosun...");
    }
    else
    {
        Console.WriteLine("Yaş Kemale Ermiş Gibi...");
    }              
   
}
else
{
    Console.WriteLine("Daha Gençsin Ya...");
}

if içerisine C/C++ dan farklı olarak sadece koşul ifadesi olarak boolean ifadeler yazılabilir. Aşağıdaki gibi bir ifade yanlıştır. Eğer j eşit midir 4 demek istiyorsanız iki eşittir kullanarak yazmanız gerekir. Bir önceki dersimizdeki operatörlere bakmanızı tavsiye ederim.
if (j = 4)
{
    // Hata Verir. j=4 ifadesi j değişkenine 4 sayısını atamak demektir.
    // yani boolean bir ifade değildir. j==4 ise j 4’ eşitmi demektir.
}

switch…case İfadesi
Karşılaştırma yapacağınız ifadenin alabileceği değerler fazla ise çok fazla if else if ifadesi yazmak yerine karşılaştırmamızı swtich…case yapısını kullanarak oluşturmamız hem kodumuzun okunurluluğu arttırır hem de daha hızlı kod yazmamızı sağlar.
switch (değişken)
{
    case sabit değer : kod bloğu;
        break;
    case sabit değer : kod bloğu;
    break;
    default:
        kod bloğu;
}

swich…case kullanımı ard arda yazılacak if..else bloklarını kullanmaktan daha kolaydır. Basit bir örnekle daha iyi anlayabiliriz.
Console.WriteLine("Lütfen Yaşınızı Giriniz");
int yas;
yas = Convert.ToInt32(Console.ReadLine());
switch (yas)
{
    case 20: Console.WriteLine("Genç Adam Merhaba");
        break;
    case 25: Console.WriteLine("Merhaba Deli Kanlı");
        break;
    case 35: Console.WriteLine("Merhaba Dayı");
        break;
    default:
        Console.WriteLine("Merhaba");
        break;
}

Yukarıdaki kodu inceleyecek olursak;  switch() içerisine karşılaştırma yapacağımız değişkeni koyuyoruz. Kontrol edeceğimiz tüm değerleri için farklı bir case bloğu yazıyoruz. Her case bloğunun break le bittiğine dikkat edin. C# break kullanmadan swtch case yazmanıza izin vermez. break; çalıştığı zaman bulunduğu kod bloğundan çıkış yapılmasını sağlar. Case bloklarından hiç birisi çalışmazsa örneğin örnekte yaş 20,25 veya 35 den hiç biri değilse default satırına yazdığımız kod çalışır.
C# da Döngülerin Kullanımı
Bir kod bloğunun belirli şartlara bağlı veya bağımsız olarak ardışık olarak çalıştırılması için döngüler kullanılır.
for  Döngüsü
En temel döngü yapısı for döngüsüdür. C# da for döngüsü kullanımı C/C++ ve Javada ki gibidir. Basit bir for döngüsünün yapısı aşağıdaki gibidir.
for (başlangıç; koşul; artım / azalım)
{
    //kod bloğu
}


Sıfırdan dokuza kadar olan sayıları konsol ekranına yazan basit bir for döngüsü yapalım.
for (int i = 0; i < 10; i++)
{
    Console.WriteLine("Döngüde i değeri şuan : {0}",i);
}

Yukarıdaki for döngüsü sonucu ekran çıktısı aşağıdaki gibi olur.
Döngüde i değeri şuan : 0
Döngüde i değeri şuan : 1
Döngüde i değeri şuan : 2
Döngüde i değeri şuan : 3
Döngüde i değeri şuan : 4
Döngüde i değeri şuan : 5
Döngüde i değeri şuan : 6
Döngüde i değeri şuan : 7
Döngüde i değeri şuan : 8
Döngüde i değeri şuan : 9
Devam etmek için bir tuşa basın . . .

Örnekte i değeri ilk olarak 0’dan başlar ve i++ ifadesine göre her döngüde bir değer artar. i<10 ifadesi i değerinin 10’dan küçük olup olmadığını kontrol eder. Eğer 10’dan küçük ise döngü içine yazılan Console.WriteLine("Döngüde i değeri şuan : {0}",i); kısmı çalışır. i değeri 10 olduğu zaman i<10 koşulu false değer üreterek döngümüzün sonlanmasına sebep olur.
for Döngüsü Hakkında Önemli Noktalar
for döngüsünde başlangıç, koşul ve artım/azalım olarak isimlendirdiğimiz kısımların üçü de opsiyoneldir.  İstersek kullanmaya biliriz. Başlangıç değerini for döngüsünden önce setleyerek döngü içinde belirli kontrolleri yapabilir, istediğimiz zamanda break komutu ile döngüyü sonlandırabiliriz. Bu kontrolleri döngü içinde de yapmazsak sonsuz bir döngümüz olur. For döngüsü aşağıdaki gibi kullanılabilir.
for (; ; )
for (; i < 10; i++)
for (int i = 3; ; i--)
for (; i < 5; )

for döngüsünü süslü parantez {} ler ile kullanmazsak for ifadesinden sonraki ilk satır döngü içinde çalıştırılır. Eğer döngü içinde birden fazla satır kod çalıştırmak istiyorsan { } parantezlerini kullanmak zorundayız. Döngü içinde tek bir satır kod bile çalıştıracak olsanız süslü parantezleri kullanmanızı tavsiye ederim.
Döngümüzü belli bir koşul altında sonlandırmak istiyorsak break komutunu kullanırız.
for (int i = 0; i < 10; i++)
{
    if (i > 5)
    {
        break;
    }
    Console.WriteLine("Döngüde i değeri şuan : {0}", i);
}

Yukarıdaki kodda i değeri 5 den büyük olduğunda break komutu çalışarak döngünün sonlanmasına sebep olur. Ekran çıktısı aşağıdaki gibi olur.
Döngüde i değeri şuan : 0
Döngüde i değeri şuan : 1
Döngüde i değeri şuan : 2
Döngüde i değeri şuan : 3
Döngüde i değeri şuan : 4
Döngüde i değeri şuan : 5
Devam etmek için bir tuşa basın . . .

Belli bir koşul altında döngü içine yazdığımız kodların çalışmayarak bir sonraki döngü adımına geçmek istiyorsak continue komutunu kullanırız.
for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        continue;
    }
    Console.WriteLine("Döngüde i değeri şuan : {0}", i);
}

i değeri 5 olduğu zaman continue komutu çalışarak döngüyü bir sonraki adıma taşır, bunun sonucu aşağıdaki ekran çıktısı oluşur.
Döngüde i değeri şuan : 0
Döngüde i değeri şuan : 1
Döngüde i değeri şuan : 2
Döngüde i değeri şuan : 3
Döngüde i değeri şuan : 4
Döngüde i değeri şuan : 6
Döngüde i değeri şuan : 7
Döngüde i değeri şuan : 8
Döngüde i değeri şuan : 9
Devam etmek için bir tuşa basın . . .

do… while Döngüsü
do…while döngüsünün temel yapısı aşağıdaki gibidir.
do
{
    // çalışacak kod
}
while(koşul);

Döngü içine yazılan kod ilk olarak çalışır daha sonra while kısmındaki koşul kontrol edilir, burada bulunan koşul true değer döndürdüğü sürece döngü tekrar tekrar çalışır.
int i = 0;
do
{
    Console.WriteLine("do while döngüsü içinde i değeri şuan: {0}", i);
    i++;
}
while (i<10);

Ekran görüntüsü;
do while döngüsü içinde i değeri şuan: 0
do while döngüsü içinde i değeri şuan: 1
do while döngüsü içinde i değeri şuan: 2
do while döngüsü içinde i değeri şuan: 3
do while döngüsü içinde i değeri şuan: 4
do while döngüsü içinde i değeri şuan: 5
do while döngüsü içinde i değeri şuan: 6
do while döngüsü içinde i değeri şuan: 7
do while döngüsü içinde i değeri şuan: 8
do while döngüsü içinde i değeri şuan: 9
Devam etmek için bir tuşa basın . . .

·         do…while döngüsü içine yazılan kod bloğu her zaman ilk seferde çalışır.
·         while ifadesinden sonra noktalı virgül kullanılır.
while Döngüsü
Hemen hemen do…while döngüsü ile aynı özellikleri taşır. Sadece ilk çalışma mantıkları farklıdır.
do…while döngüsü ilk olarak kod bloğuna girer daha sonra koşul kontrol edilir, böylece koşul doğru olsada olmasada kod bloğu bir kez çalışır.
while döngüsü ise kod bloğuna girmeden önce koşul durumunu kontrol eder, eğer koşul doğru değilse kod bloğu asla çalışmaz. Bu küçük ama çok önemli bir farktır.
while döngüsünün yapısı
while (koşul)
{
    //kod bloğu
}

Koşul ifadesi doğru ise while içinde yazılan kod bloğu çalışır. koşul yanlış olduğu anda döngü sona erer.
int sayac = 0;
while (sayac<10)
{
    Console.WriteLine("Sayac Değeri: {0}",sayac);
    sayac++;
}

Döngüleri kullanarak basit bir örnek yapalım. Örneğin Ekrandan kullanıcı adını alalım. Kullanıcı adı bizim istediğimiz değer olana kadar kullanıcı adını istemeye devam edelim. Bizim istediğimiz kullanıcı adı yazıldığı zaman bir mesaj vererek döngüden çıkalım. Bu örneğimizi do…while veya while döngüsü ile yapabiliriz. Biz örneğimize while döngüsü ile nasıl yapılacağını anlatacağız.
string kullaniciAdi = "";
while (kullaniciAdi != "Sabri")
{
    Console.WriteLine("Lütfen Kullanici Adını Yazınız.");
    kullaniciAdi = Console.ReadLine();
}
Console.WriteLine("Hoşgeldin Sabri.");

while içindeki koşul şartı kullaniciAdi Sabri olmadığı sürece doğru değeri döndürür. Bu yüzdende Sabri ismi girilene kadar döngü sonlanmaz. Aynı işlemi aşağıdaki gibide yapabiliriz.
string kullaniciAdi = "";
while (true)
{
    Console.WriteLine("Lütfen Kullanici Adını Yazınız.");
    kullaniciAdi = Console.ReadLine();
    if (kullaniciAdi == "Sabri")
    {
        Console.WriteLine("Hoşgeldin Sabri.");
        break;
    }
}

Yukarıdaki kod örneğinde while içine direk olarak true değeri yazdık, böylece döngünün asla sonlanmamasını sağladık fakat döngü içinde if koşulu ile kullaniciAdi kontrol ediliyor ve eğer Sabri olarak girilmişse break komutu ile döngüyü sonlandırıyoruz
Devamını Oku

Değişken Tipleri, Değişken Tanımlama ve Operatörler


C# Hakkında Temel Bilgiler

Bu dersimizde C# dili hakkında temel bilgiler öğreneceğiz. Biraz açarsak bu dersimizde veri tipleri, değişkenler ve operatörleri nasıl kullanacağımızla ilgili bilgiler vereceğiz.

Temel Veri Tipleri ve CTS(Common Type System) Karşılıkları

C# da iki çeşit veri tipi vardır:
  • Değer Tipleri (Value type)
  • Referans Tipleri(Reference Type)
Değişkenler bellekte bulunan verilerdir. Bir değişkeni kullandığımız zaman o değişkenin bellekte bulundu yerdeki bilgiyi kullanırız. Değer tipleri veriyi direk olarak bellek bölgesinden alırken referans tipleri başka bir nesneye referans gösterirler. Yani referans tipleri içinde veri değil adres bilgisi tutarlar. Veri tipleri stack dediğimiz bellek bölgesinde tutulurlar, referans tipleri ise heap bellek bölgesinde saklanırlar. int, double, float gibi veri tipleri değer tiplerine örnek gösterilebilir. Herhangi bir sınıf türü ise referans tipine örnek gösterilebilir. Değer tipleri birbirine eşitlenirken değişkenin barındırdığı değer bir diğer değişkene kopyalanır. Böylece iki farklı bağımsız değişken oluşur. Referans tipleri ise eşitleme sırasında değişkenlerin taşıdıkları veri değil heap bölgesinde işaret ettikleri adres kopyalanır. Böylece eğer iki referans değişkeni birbirine eşitledi isek ve daha sonra bunlardan birinde bulunan veriyi değiştirdi ise otomatik olarak diğer referans değişkeninin değeri de değişir. Çünkü adresde bulunan veri değişince bu adresi işaret eden iki değişkende yeni veri bilgisine ulaşır.
Bir önceki dersimizde Common Type System hakkında bilgi vermiştik. C# da tanımlanan veri tipleri ve bunların CTS deki karşılıklarını tablo halinde aşağıda bulabilirsiniz. C# da toplam 15 veri tipi vardır bunlardan 13 ü değer tipindedir, 2 si ise referans tipindedir.

Değer Tipleri:

C# AdıCTS KarşılığıAçıklamaMax ve Min aralık yada değeri
sbyteSystem.Byte8 bit işaretli tamsayı-128 : 127
shortSystem.Int1616 bit işaretli tamsayı-32.768 : 32.767
intSystem.Int3232 bit işaretli tamsayı-2.147.483.648 : 2.147.483.647
longSystem.Int6464 bit işaretli tamsayı-9.223.372.036.854.775.808 : -9.223.372.036.854.775.807
byteSystem.Byte8 bit işaretsiz tamsayı0,177083333
ushortSystem.UInt1616 bit işaretsiz tamsayı0 : 65.535
uintSystem.UInt3232 bit işaretsiz tamsayı0 : 4.294.967.295
ulongSystem.UInt6464 bit işaretsiz tamsayı0 : 18.446.744.073.709.551.615
floatSystem.Single32 bit tek kayan sayı+yada - 1,5*10-45 : + ya da - 3,4*1038
doubleSytem.Double64 bit çift kayan sayı+yada - 5*10-324 : + ya da - 1,7*10308
decimalSystem.Decimal128 bit ondalıklı sayı+yada - 1,5*10-28 : + ya da - 7,9*1028
boolSystem.Booleantrue ya da false
charSystem.CharKarakterleri temsil eder16 Unicode karakterleri

Referans Tipleri:

C# AdıCTS KarşılığıAçıklama
objectSystem.ObjectBütün veri türlerinin türediği kök eleman
stringSystem.StringUnicode karakterlerinden oluşan string

Değişkenler:

Bir program çalıştırırken tüm veriler geçici olarak hafızada tutulur. Değişkenler bu verilerin isimlendirilmesi işlemidir. C# da değişkenler aşağıdaki yapıda tanımlanırlar.
?
1
<veri tipi><değişken adı>;

Örneğin;

?
1
int i;
Yukarıdaki ifade bir integer veri tipini saklamak için programın diğer aşamalarında i ismi ile ifade edilecek hafızada 4 bytelık bir alan açar. Bir değişkene tanımlarken değer atayabilirsiniz, ayrıca bir veri tipi altında birden fazla isimle farklı değişkenler tanımlayabilirsiniz.
?
1
2
3
bool dogruMu = false;
double yuzde = 98.32, ortalama = 35.32;
char karakter = 'A';
Diğer modern programlama dilleri gibi C# dada değişkenleri kullanmadan önce tanımlamak zorundasınız.  Ayrıca eğer bir yerel değişken (Bir method içinde tanımlanan değişkenler) tanımlıyorsanız bu değişkeni kullanmadan önce bir değer ataması yapmak zorundasınız.
?
1
2
3
4
5
6
static void Main(string[] args)
{
      int kilo;
      //kilo = 78;
      Console.WriteLine(kilo);
}
Yukarıdaki kod parçacığı kilo değişkenine değer atamadığınız için hata verecektir çünkü kilo değişkeni yerel bir değişkendir. Eğer //kilo = 78; açıklama satırındaki //işaretlerini siler ve bu satırı koda dahil ederseniz hatanın ortadan kalktığını görürsünüz. Buradan da anlaşılacağı gibi C# yerel değişkenlere ilk atama işlemini otomatik yapmak global değişkenler de ise ilk değer ataması değişken tipine göre otomatik olarak yapılır. Örneğin integer bir tip için 0 gibi.

Sabit Değişkenler:

Sabit değişkenler içinde buluna veri değişken ömrü tamamlanana kadar değişmez. Bir sabit tanımlamak için const anahtar kelimesini kullanırız. İlk tanımlandıkları sırada ilk değer ataması yapmak zorundayız, uygulamamızın herhangi bir kısmında sabit değişkenin içeriğini değiştiremeyiz.
?
1
2
const double PI = 3.14;
const double PI;
Yukarıdaki tanımlamalardan birincisi doğru ikincisi ise yanlış bir tanımlamadır. İlk atamaları yapılmak zorundadır.
Sabitler genellikle büyük harflerle tanımlanırlar. Bu bir zorunluluk değildir.

Değişkenler ve Metotlar için İsimlendirme Konvansiyonları

Microsoft değişken isimlendirmesi için Camel Notasyonu methotlar için ise Pascal Notasyonunu tavsiye ediyor.
Camel notasyonunda isim küçük harfle başlar, eğer değişken isminde birden fazla kelime geçiyor ise isimdeki diğer kelimeler büyük harfle başlar.

Camel Notasyonu:

?
1
2
3
maas;
maasMiktari;
massMiktariAciklama;
Pascal Notasyonunda kelime büyük harfle başlar. Camel Notasyonunda olduğu gibi diğer kelimelerde büyük harfle başlar.

Pascal Notasyonu:

?
1
2
Maas();
MaasHesapla();
Bu notasyonların kullanımı mecburi değildir. Fakat sürekli olarak bu tür bir notasyona uyarak kodlarınızı yazarsanız, kodlarınız daha anlaşılır bir hale girer.

C# da Operatörler

Aritmetik Operatörler

OperatörAçıklama
+Ekleme
-Çıkarma
*Çarpma
/Bölme
%Kalan veya modül
++Birer Birer Arttırma
--Birer Birer Eksiltme
Yukarıdaki tablodaki operatörlerin kullanımı ile ilgili örnek kod aşağıdadır. Ayrıca kodu buradan indirerek kendiniz deneyebilirsiniz.
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static void Main()
{
    int toplam = 0, fark = 0, carpim = 0, kalan = 0;
    float bolum = 0;
    int sayi1 = 0, sayi2 = 0;
         
    Console.WriteLine("Sayı Biri Giriniz : ");
    sayi1 = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine("Sayı İkiyi Giriniz : ");
    sayi2 = Convert.ToInt32(Console.ReadLine());
    toplam = sayi1 + sayi2;
    fark = sayi1 - sayi2;
    carpim = sayi1 * sayi2;
    kalan = sayi1 % sayi2;
    bolum = sayi1 / sayi2;
         
    Console.WriteLine("Girilen Sayılar: Sayı 1 = {0}, Sayı 2 = {1}",
            sayi1, sayi2);
    Console.WriteLine("Sayıların Toplamı = {0}", toplam);
    Console.WriteLine("Sayıların Farkı (sayi1 - sayi2) = {0}", fark);
    Console.WriteLine("Sayıların Çarpımı = {0}", carpim);
    Console.WriteLine("Sayıların kalan (sayi1 in sayi2 ye bölümğnden kalan)= {0}"
            , kalan);
    Console.WriteLine("Sayıların Bölümünden (sayi1 / sayi2) Bölüm = {0}", bolum);
    sayi1++;
    sayi2--;
    Console.WriteLine("Sayi 1 in bir fazlası = {0}", sayi1);
    Console.WriteLine("Sayi 2 in bir eksiği = {0}", sayi2);
}
Yukarıdaki kodu inceleyecek olursanız. Console.WriteLine("Açıklama Metni {0}" , sayi1); gibi bir yapı görürsünüz. String ifadelerde stringİfade1 + stringİfade2 şeklinde birleştirme yapmak yerine bu formatta stringleri birleştirebilirsiniz. {0}  şeklindeki ifade virgülden sonra yazılan ilk değişkenin değerini buraya yaz demek oluyor. Eğer ikinci bir değişken varsa {1} şeklinde yazarak onunda değerini başka bir kısma yerleştirebiliriz. Dikkat etmeniz gereken {} ifadesinin içindeki sayılar sırası ile gitmeli. Yani 0, 1, 2,..
?
1
sayi1++ ifadesi
ile
?
1
sayi1 = sayi1 + 1;
aynı anlama gelmektedir. Ayrıca bir sayıya herhangi bir sayı eklemek istiyorsak örneğin sayi1 e 5 ekleyelim.
?
1
sayi1 = sayi1 +5
yazmak yerine;
?
1
sayi += 5;
daha kısa ve doğrudur.

Ön Ek ve Arka Ek Olarak Kullanma

++ ve – operatörleri en ve arka ek olarak kullanılabilir. Örneklerle anlatacak olursak;
?
1
2
3
sayi2 = 3;
sayi1 = ++sayi2;//sayi1 = 4, sayi2= 4 olur.
sayi1 = --sayi2;//sayi1 = 2, sayi2= 2 olur.
Örnekte görüldüğü gibi eğer operator ön ek olarak kullanılırsa derleyici önce operatörün görevini yapar daha sonra ise atama işlemini gerçekleştirir. Böylece sayi1 = ++sayi2 ifadesinde sayi2 önce bir arttırılır daha sonra sayi1’e sayi2 nin değeri atanır.
?
1
2
3
sayi2 = 3;
sayi1 = sayi2++; //sayi1 = 3, sayi2= 4 olur.
sayi1 = sayi2--; //sayi1 = 3, sayi2= 2 olur.
Operatör arka ek olarak kullanıldığında ise önce atama işlemi yapılar daha sonra operatörün görevi yerine getirilir. sayi1 = sayi2++ işleminde önce sayi2 nin değeri sayi1’e atanır, daha sonra sayi2 bir arttırılır.

Atama Operatörleri

Atama Operatörleri değişkenlere değer atamak için kullanılırlar.
OperatörAçıklama
=Basit eşitleme
+=Sağdaki Sayı ile topla sonra toplamı eşitle
-=Sağdaki Sayı yı çıkar sonra sonucu eşitle
*=Sağdaki Sayı ile çarp sonra toplamı eşitle
/=Sağdaki Sayı ile böl sonra bölümü eşitle
%=Sağdaki Sayı ile bölümünden kalanı bul sonra kalanı eşitle

İlişkisel(Karşılaştırma) Operatörleri

İlişkisel Operatörler genelde koşul ifadelerinde karşılaştırma için kullanılırlar. C#da kullanılan ilişkisel operatörler aşağıdakilerdir.
OperatörAçıklama
==Eşittir
!=Eşit Değildir
Büyüktür
Küçüktür
>=Büyük Eşittir
<=Küçük Eşittir
İlişkisel Operatörler her zaman true veya false olmak üzere boolean bir değer döndürürler.  Örnekle anlatmamız gerekirse;
?
1
2
3
4
5
6
7
int sayi1 = 6, sayi2 = 4;
sayi1 == sayi2 //false;
sayi1 != sayi2 //true;
sayi1 > sayi2 //true;
sayi1 < sayi2 //false;
sayi1 >= sayi2 //true;
sayi1 <= sayi2 //false;
İlişkisel operatörler sadece birbiri ile uyumlu tipteki değişkenleri karşılaştırabilir. Bir boolean tipi ile integer tipindeki iki değişkeni karşılaştıramazsınız.

Mantıksal ve Bit Düzeyinde (Logical and Bitwise) Opeatörleri

Bu operatörler mantıksal işlemleri ve bit düzeyindeki işlemleri yapmak için kullanılırlar.
OperatörAçıklama
&Bit bazında ve işlemi
|Bit bazında or işlemi
^Bit bazında xor işlemi
!Bit bazında not işlemi
&&Mantıksal ve işlemi
||Mantıksal or işlemi
Bit bazındaki operatörler değişkene ait değeri bit bazında işleme tabi tutarlar. Mantıksal operatörler ise bildiğimiz mantık kavramı kapsamında bu ve şu doğrumu veya bu veya şu doğrumu gibi karşılaştırma yaparlar.
?
1
bool sonuc = (i > 3 && j < 5) || (i < 7 && j > 3);
Mantıksal operatörlerde;
?
1
2
3
4
5
6
7
8
Doğru ve Doğru = Doğru;
Doğru ve Yanlış = Yanlış;
Yanlış ve Doğru = Yanlış;
Yanlış ve Yanlış = Yanlış;
Doğru veya Doğru = Doğru;
Doğru veya Yanlış = Doğru;
Yanlış veya Doğru = Doğru;
Yanlış veya Yanlış = Yanlış;
Mantıksal And işlemlerinde eğer koşullardan herhangi biri yanlış ise and işlemine tabi tutulan diğer koşullar true olsa bile sonuç falsedur. Or işleminde ise koşullardan herhangi birinin true olması diğer koşulların ne olduğuna bakmaksızın sonucun true olmasını sağlar.
C# Mantıksal operatörler Kısa Devre mantığıyla çalışır. Mantıksal işlemlerde koşullar soldan sağa doğru kontrol edilir. Yukarıdaki paragraftaki bilgiye göre; bir and işlemi kontrol ediliyorsa ve koşullardan birisi false ise sağda kaç adet daha and koşulu olmasına bakmaksızın sonucu false olarak belirleyebiliriz. C# derleyicisi de bu yöntemi kullanarak and işleminde ilk false gördüğü anda or işleminde ise ilk true gördüğü anda işlemi keser ve sonucu döndürür. Bu büyük uygulamalarda çok fazla koşul olduğu zamanlar uygulamamızın daha hızlı çalışmasını sağlar.

C# da Kullanılan Diğer Operatörler

OperatörAçıklama
>> Bit bazında sağa kaydırma
<< Bit bazında sola kaydırma
,Nesnelerin özelliklerine ulaşmak için
[]İndeks numarası ile dizi ve kolleksiyonların elemanlarına ulaşmak
()Çevrim Operatörü. Tip çevrimleri için kullanılır.
?:Koşul Operatörü. if else koşulunun kısa yazımı. İlerde anlatılacak

Operatörlerde Çalışma Önceliği

Tüm operatörlerin çalışma önceliği aynı değildir. Matematik kurallarında geçerli olan çarpma, bölme, çıkarma toplama işlemlerindeki öncelik sırası operatörler içinde geçerlidir. Öncelikleri belirlemek için işlemleri parantez içinde yazmamız gerekir. Örneğin
?
1
2
3
4
5
int i = 3 + 2 * 6;
// önce 2 ile 6 çarpılır daha sonra çarpıma 3 eklenerek 15 bulunur.
int j = (3 + 2) * 6;
// önce 3 ile 2 toplanır daha sonra toplam 6 ile çarpılarak 30 bulunur.
Devamını Oku