Temel C# Dersleri

Unity ile mobil oyun yapabilmek için bildiğiniz üzere C# bilmemiz gerekiyor. Unity oyun motorunun kullandığı kendi fonksiyonları ve sınıfları yer alıyor ama bunları anlamadan önce temel bir C# eğitimi almamız gerekecek.

Unity ile oyun programlamaya yeni başlayan arkadaşlardan programlama diline yatkın olma avantajım olacak. Fakat işim gereği JavaScript ve Java dillerini bildiğim için ve ben de C# konusunda yeni olacağım.

Biraz ek bilgi verelim…

C#, 2000 yılında Microsoft tarafından çıkarılan nesne tabanlı bir programlama dilidir. Genellikle diğer nesne tabanlı programlama dilleri arasından olan Java ile kıyaslanıyor. Hatta daha önceden hangi yazılım dilini öğrenmeliyim diye araştırma yaptıysanız Java mı C# mı diye soruları çok görmüşsünüzdür.

Bir tartışma ortamı yaratmak istemem ama benim gözlemlediğim 5 yıl önce Java çok aktif olarak Türkiye’deki büyük firmaları parsellemişti. Fakat yeni açılan startup ya da orta ölçekli firmalara baktığımda C# ile başladıklarını ya da mevcut sistemlerini değiştirdiklerini gördüm. Bu yüzden zaten zorunlu olarak Unity için C# öğrenmemiz bizim için ileri ki süreçte ek bir avantaj olacaktır.

Hadi başlayalım…

C# kodlarını yazabilmemiz için bize bir IDE yani editör programı gerekiyor. IDE seçimi olarak Unity’i destekleyen programlardan biri olan Visual Studio ile çalışmalarımıza devam edeceğiz. Zaten Unity kurulumu dersinde Microsoft Visual Studio Community 2019 sürümünü, Unity’ye modül olarak eklemiştik.

Unity İçin Editör Seçimi

Öncelikle ilk yapmamız gereken Unity üzerinden varsayılan editör olarak Visual Studio seçimi yapmak olacak. Ama bunun için önce at kısımda yer alan “Project” alanı içerisinde yer alan “Assets” klasörü içinde “Sağ Tık /Create / Folder” yaparak “Scripts” isminde bir klasör oluşturuyoruz.

Klasörü oluşturduktan sonra içerisine girerek ilk C# dosyamızı oluşturacağız. İsim olarak “TemelCDersleri” olarak belirledim. Sizde içinde TR karakter geçmeyen ve ilk harfleri büyük olan bir isim belirleyebilirsiniz.

Evet şimdi eklemiş olduğumuz “TemelCDersleri” dosyasını tıklayarak açalım. Eğer “Visual Studio” ile açmayıp “notepad” programı ile açarsa üst kısımda yer alan “Edit/Preferences” menüsüne girip “External Tools” kısmına tıklayın.

Pencerede “External Script Editor” isminde bir kısım göreceksiniz. Eğer notopad ile açılıyorsa burada “Open by file extension” yazısını görürsünüz. Seçeneklere tıklayarak Visual Studio 2019(Community) seçebilirsiniz. Eğer Visual Studio hiç gelmiyorsa “Browse” seçeneğine tıklayarak aşağıda belirttiğim adresten Visual Studio editörünü seçmeniz yeterli olacaktır.

“C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\devenv.exe”

Evet Unity standartlarına göre C# çalışmalarımızı atacağımız scripts klasörümüzü ve C# dosyamızı oluşturarak, editör ayarlamasını yaptık. Şimdi oluşturduğunuz “TemelCDersleri” dosyasına tıklayarak Visual Studio ile C# dosyamızı açıyoruz.

Karşımıza açılan pencerede aşağıdaki gibi bir yazı göreceksiniz. Burada yazan “void Start“, “void Update” gibi kısımlar Unity’nin kendi fonksiyonları daha sonralı bunları detaylı inceleyeceğiz. Şimdilik sadece C# temel kodlarına odaklanalım.

public class TemelCDersleri : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

Değişken Tanımlama Kuralları

C#’da değişken tanımlama kuralları konusundan sonra farklı değişken türlerini inceleyeceğiz ve bu değişken türlerine isimler vereceğiz. Değişkenleri tanımlarken vereceğimiz isimlerde bazı kurallar bulunmaktadır. Bu kuralların bazıları zorunlu olup eğer uygulamazsanız hata alırsınız. Fakat bazıları ise yazılı olmayan ama kabul görmüş tanımlama kurallarıdır.

• Değişken ismi hiç bir zaman bir sayı ile başlayamaz. Fakat ilk harf haricinde değişken isminin istediğiniz kısmında sayı kullanabilirsiniz. Örneğin değişken ismini ders1 yapabilirsiniz ama 1ders yapamazsınız.
• Değişken isimlerinde alt çizgi(_) haricinde herhangi bir karakter içeremez. Fakat alt çizgi(_) kullanımı da genellikle tavsiye edilmez. Örneğin hasar-gucu, hasar/gucu-, ?hasargucu gibi tanımalamalar yapamazsınız ama vurus_gucu şeklinde tanımlama yapabilirsiniz.
• Değişken isimlerinde boşluk kullanılamaz.
• Değişken isimleri büyük, küçük harfe karşı duyarlıdır. Yani Elma ve elma aynı değildir.
• Değişken isimleri Türkçe karakterler içerebilir fakat kesinlikle tavsiye edilmez.
• Programlama dilinde kullanılan if, else, true, char gibi tüm terimler kullanılamaz.

Değişken tanımlamalarında standart olarak kabul edilen yönteme camelCase biçimi denmektedir. Bu isimlendirme biçiminde ilk harf her zaman küçük harfle başlayıp ikici kelimenin ilk harfi büyük harfle yazılır.

Örneğin dusmanSayisi, karakterSecimi örnek değişken isimlerinde olduğu gibi İlk harf küçük ve ikinci kelimenin ilk harfi büyük.

Arkadaşlar tavsiyem camelCase gibi genelleşmiş kalıplara uymanız ve değişken, fonksiyon sınıf gibi oluşturacağınız tüm isimlendirmeler de İngilizce cümleler kullanmanız olacaktır.

Değişkenler

Her dilde olduğu gibi yine ilk öğreneceğimiz şey değişken kavramı olacaktır. En basit anlatımıyla C# dilinin izin verdiği koşullarda verileri saklamamızı sağlayan bir yapı diyebiliriz.

C# programlama dilinde 14 adet değişken tanımlama yöntemi bulunmaktadır. Fakat genellikle kullanılan ve Unity üzerinde de aktif olarak kullanacağımız 7 adet değişken türü bulunmaktadır. En çok kullanacağımız değişken türleri string, int, float, double, Boolean ve char üzerine ekstra değineceğiz.

Tür	Boyut	Açıklama
int	4 bayt	-2.147.483.648 ile +2.147.483.647 arasındaki tam sayılar için kullanılır.
long	8 bayt	-9.223.372.036.854.775.808 ile 9.223.372.036.854.775.807 arasındaki tam sayılar için kullanılır
float	4 bayt	Kesirli sayılar için kullanılır. ±1.5*10-45, …, ±3.4*1038 arasında sayılar için kullanılır.
double	8 bayt	Kesirli sayılar için kullanılır. ±5.0*10-324, …, ±1.7*10308 arasında sayılar için kullanılır.
bool	1 bit	true ya da false değeri alır.
char	2 bayt	Tek bir karakter-harf için kullanılır.
string	Her harf 2 byte	Birden fazla karakter yani kelimeler, cümleler için kullanılır.

Boyut alanında belirtilen değerler her bir değişkenin kapladığı depolama alanını belirtmektedir.

Integer ve Long Değişkenleri

“Integer” ve “Long” değişkenler tam sayı barındırırlar. Genellikle “int” değişkenini kullanacağız fakat 2.147.483.647 sayısından büyük ya da -2.147.483.647 sayısından küçük bir sayı kullanmanız gerekirse “long” değişkenini tanımlamanız gerekecektir.

Integer = int ve Long = long olarak ifade edilir.

public class TemelCDersleri : MonoBehaviour
{
    int sayi1 = 37;
    long sayi2 = 2147483648;
    void Start()
    {
        Debug.Log("Birinci Sayı: " + sayi1);
        Debug.Log("İkinci Sayı: " + sayi2);
    }

  
}

Örneğin yukarıdaki kodda görüldüğü gibi 37 sayısını “sayi1” isminde Integer(int) değişkene ve 2147483648 sayısını “sayi2” isminde Long(long) bir değişkene tanımladık. Sonrasında ise “Debug.Log(sayi)” ile tanımladığımız “sayi1” ve “sayi2” değişkenlerini Unity Console penceresine bastırdık.

Double ve Float Değişkenleri

Double ve Float değişken türleri ondalıklı sayılar için kullanılmaktadır. Integer tam sayı değişkeninden farklı olarak atama yaparken Float için “F” ve Double için “D” harfini eklememiz gerekmektedir.

Double = double ve Float = float olarak ifade edilir.

public class TemelCDersleri : MonoBehaviour
{
    float sayi1 = 11.22F;
    double sayi2 = 22.345223D;
    void Start()
    {
        Debug.Log("Birinci Sayı: " + sayi1);
        Debug.Log("İkinci Sayı: " + sayi2);
    }
}

Örneğin yukarıdaki kodda görüldüğü gibi 11.22 ondalıklı sayısını “sayi1” isminde Float(float) değişkene ve 22.345223 ondalıklı sayısını “sayi2” isminde Double(double) değişkene tanımladık. Sonrasında ise “Debug.Log(sayi)” ile tanımladığımız “sayi1” ve “sayi2” değişkenlerini Unity Console penceresine bastırdık.

String ve Char Değişkenleri

“Char” değişkenini sadece tek bir harf atamak için kullanabiliyoruz. Tek bir harften fazla tanımlamak istediğimizde “Char” yerine “String” değişkenini kullanmanız gerekmektedir.

Char değişkenlere atanan değerler ” – tek tırnak ile ayrılırken String değişkenlere atanan değerler “” – çift tırak ile ayrılması gerekmektedir.

Char = char ve String = string olarak ifade edilir.

public class TemelCDersleri : MonoBehaviour
{
    char harf = 'B';
    string kelime = "Barış";
    string tekHarf = "B";
    void Start()
    {
        Debug.Log("Char Örnek: " + harf);
        Debug.Log("String Örnek: " + kelime);
        Debug.Log("String Tek Harf Örnek: " + tekHarf);
    }
}

Örneğin yukarıdaki kodda görüldüğü gibi “B” harfini “harf” isminde Char(char) değişkene ve “Barış” kelimesini “kelime” isminde String(string) değişkene tanımladık.

string tekHarf = "B" örneğinde görüldüğü gibi Char değişkeni için tek bir harf tanımlanabileceği gibi String bir değişken içinde tek bir harf tanımlaması yapılabilir. Burada aslında anlamamız gereken durum atayacağımız değeri eğer tırnak işaretleri içerisine alırsak otomatik olarak String bir değişken olur. Bu duruma “1”, “-100”, “1,3”, “false” gibi diğer tanımlama çeşitlerinin hepsi dahildir.

Boolean Değişkeni

“Boolean” değişkenine sadece true ve false değerleri atanabilmektedir. Programlama dilinde en çok kullanılan değişken türlerinden biridir. İleri de if-else bloglarında ya da teyit amaçlı gibi birçok alanda kullanacağız.

Boolean değişkeni “bool” kelimesiyle tanımlanır.

public class TemelCDersleri : MonoBehaviour
{
    bool dogruMu = true;
    void Start()
    {
        Debug.Log("Doğru mu: " + dogruMu);   
    }
}

Örneğin yukarıdaki kodda görüldüğü gibi true değerini “dogruMu” isminde Boolean(bool) değişkene atadık ve unity debug penceresinde görebilmemiz için “Debug.Log(dogruMu)” koduyla bastırdık.

if .. else yapısına, Do-While gibi yapılara ya da for, foreach gibi döngülerin konularına sürekli olarak operatörleri kullanacağımız için, bu konulara girmeden önce mantıksal ve karşılaştırma operatörlerini bilmemiz gerekiyor.

Array(Dizi) Kullanımı

C#’da belirli veri tiplerini bir araya getirmek için kullanılan sınıflardır. Oyun programlamada karşımıza oldukça fazla çıkacak bir yapı olduğu için ve çalışmayı kolaylaştırdığı için önemli bir konudur.

Oyun programlama da genellikle “Tek boyutlu diziler” kullanılır ama diğer türleri olan “Çok boyutlu diziler” ve “Düzensiz diziler” konularında da ufaktan değineceğiz.

Çalışma mantığı için şöyle düşünebilirsiniz. Örneğin 100 tane “Integer” değişken oluşturmanız gerekiyor. Bu değişkenleri tek tek oluşturmanızın ve her birine isim belirlemeye çalışmanızın ne kadar zor olacağını düşünün. İste burada devreye Array diziler giriyor.

Array Oluşturma Yöntemleri

Dizi oluşturmanın birkaç yöntemi bulunmaktadır. Önce genel tanımlama yöntemlerinden bahsedeceğim ve sonlara doğru en pratik olan dizi tanımlama yöntemini inceleyeceğiz.

int[] numaralar = new int[5];
string[] isimler = new string[2];

Yukarıdaki örnekte bir standart bir Integer ya da String oluşturma aşamasından farklı olduğunu görmüşsünüzdür. Eğer bir tanımlamada köşeli parantez görüyorsanız bu tanımlamanın bir array yani dizi olduğunu anlayabilirsiniz. int[] numaralar ile başlayarak numaralar isminde bir Integer dizi oluşturduğumuzu ve string[] isimler ile başlayarak bir String dizi oluşturduğumuzu belirtiyoruz.

new int[5] ve new string[2] alanları ise oluşturduğumuz dizinin kaç elemanlı olacağını belirtiyoruz.

Diğer dizi oluşturma yöntemi ise direk elemanlarını belirteceğimiz tanımlama yöntemidir. Yukarıda belirttiğimiz tanımlamadan farkı ise eleman sayısını belirtmek yerine içerisinde yer alan elemanları belirtiyoruz.

int[] numaralar = new int[]{1,2,3,77,44,12};

En basit ve kullanmak isteyeceğiniz yöntem ise aşağıdaki gibidir.

int[] numaralar = {1,15,8,11,23};

Bu yöntemde sadece köşeli parantezle bir array olduğunu belirttikten sonra süslü parantezlerle içerisinde yer alacak elemanları belirtiyorsunuz.

Dizi Elemanlarına Erişmek

Evet nasıl dizi oluşturacağımızı gördük peki bu dizini içerisinde yer alan bir elemana nasıl erişebileceğiz. Bunun için öncelikle index mantığını anlamamız gerekiyor.

Örneğin 5 elemanlı bir Integer dizi oluşturalım.

int[] sayilar = {55,23,68,33,11};

Bu oluşturduğumuz dizinin 5 elemanı array içinde aşağıdaki gibi yer almaktadır.

1 eleman olan 55, dizinin 0 index’inde yer almaktadır.
2 eleman olan 23, dizinin 1 index’inde yer almaktadır.
3 eleman olan 68, dizinin 2 index’inde yer almaktadır.
4 eleman olan 33, dizinin 3 index’inde yer almaktadır.
5 eleman olan 11, dizinin 4 index’inde yer almaktadır.

Yani dizinin içerisindeki 1. elemana erişeceğiniz zaman 0. index numarasına bakmanız gerekiyor. Tüm programlama dillerinde istisnai bir durum olmadığı sürece başlangıçlar 1 yerine 0’dır.

Diziye atadığımız sayıların hangi index numarasında olduğunu anladığımıza göre şimdi nasıl erişebileceğimize bakalım.

int[] sayilar = {55,23,68,33,11};
Debug.Log(sayilar[0]);

Sonuç: 55

Aynı sayılar dizisinde 1. elemana erişmek için sayilar[0] şeklide yani köşeli parantez içinde ulaşmak istediğimiz index numarasını yazarak kullanmalıyız. Ya da “11” sayısına erişmek içinse sayilar[4] şeklinde yazmalıyız.

Çift Boyutlu ve Düzensiz Diziler

Şu ana kadar bahsettiklerimiz tek boyutlu dizilerdi. Konunun başında bahsettiğim gibi çift boyutlu ve düzensiz diziler içinde bir örnek vereceğim. Fakat biraz daha zor ve unity ile oyun programlarken karşımıza çok çıkmadığı için mantığını anlamanız yeterli olacaktır.

Örneğin çift boyutlu String türünde olan bir isimler dizisi oluşturalım.

string[][] isimler = new string[3][];

Örnekte gördüğümüz gibi tek boyutlu dizilerde tek köşeli parantez olurken çift boyutlu dizlerde ikişer adet köşeli parantez bulunmaktadır.

Çift boyutlu dizilerdeki mantığı aslında dizi içinde dizi olması diye düşünebilirsiniz.

Yukarıda isimler isminde bir string dizi oluşturduk ve içerisinde 3 elaman olduğunu belirttik. Aslında buradaki 3 eleman diye bahsettiğimiz kısım dizi içerisinde 3 dizi daha olduğu anlamına gelmektedir.

isimler[0] = new string[] {"Barış", "Yelda", "Çağatay"};
isimler[1] = new string[] {"Türkan", "Tüncer", "Bahar"};
isimler[2] = new string[] {"Figen", "Yekta", "Hande", "Mustafa"};

Gördüğümüz gibi her bir index numarasına farklı bir dizi tanımladık. Bu dizilerdeki elemanlara erişmek için ise isimler[0][1] ya da isimler[2][0] gibi yöntemler kullanırız.

isimler[0] = new string[] {"Barış", "Yelda", "Çağatay"};
isimler[1] = new string[] {"Türkan", "Tüncer", "Bahar"};
isimler[2] = new string[] {"Figen", "Yekta", "Hande", "Mustafa"};

Debug.Log(isimler[0][1]);
Debug.Log(isimler[2][0]);

Sonuç: “Yelda” ve “Figen”

isimler[0][1] ile sıfırıncı index numarasında yer alan dizinin birinci indexinde yer alan elemanı

isimler[2][0] ile ikinci index numarasında yer alan dizinin sıfırıncı indexinde yer alan elemanı

Yukarıdaki örnekte çift boyutlu dizileri ve düzensiz dizileri gösterdim. Düzensiz dizlerde nerden çıktı derseniz eğer. Fark ettiyseniz isimler[2] dizisinde 4 adet eleman bulunmaktadır. Bu şekilde eleman sayısının farklı olduğu diziler oluşturmaya ise düzensiz diziler denmektedir.

Mantıksal ve Karşılaştırma Operatörleri

Tek başlarına anlamları olmayan ama çoğu durumda bazı değişkenleri ya da çıktıları karşılaştırmamıza yarayan operatörlere karşılaştırma operatörleri denir. Kontrol etmemiz yarayan operatörlere ise mantıksal operatörler denir. C#’da 6 adet karşılaştırma ve 3 adet mantıksal operatör bulunmaktadır.

Kodlama işlemleri sırasında sürekli karşımıza çıkacağı için ezbere bilmeniz faydalı olacaktır.

Karşılaştırma Operatörü	Anlamı
<	Küçükse
>	Büyükse
<=	Küçük ve Eşitse
>=	Büyük ve Eşitse
==	Eşitse
!=	Eşit Değilse

Mantıksal Operatör	Anlamı
&&	Ve
||	Veya
!	Değilse

if … else Koşul Yapısı

Net olarak söyleyebilirim ki if-else koşul yapısı for döngüsüyle birlikte programlamada en çok karşınıza çıkacak yapılardan biridir. Bu sebeple bu kısmı net olarak anlamanız çok önemli.

Moral açısından şöyle söyleyeyim çalıştığım bazı kurumsal firmalarda sadece if-else, for ve do-while döngüsüyle çalışma hayatlarına devam edenler görüyorum.

if, else if ve else anahtar kelimelerini kullanılarak belirli koşulların sağlanması ya da sağlanmaması durumuna göre belirli kodları çalıştıran bir kod bloğudur.

Fakat if … else yapısını öğrenmeden önce bu yapıların içerisinde sürekli olarak kullanacağımız mantıksal ve karşılaştırma operatörlerini öğrenmemiz gerekiyor.

if … else döngüsünü en iyi örneklerle anlayabilirsiniz o yüzden örneklere geçeceğim. Örneğin televizyonun karşısına geçtik ve kumandadan açma tuşuna bastık ama televizyon çalışmadı.

if(televizyonun fişi takılı değil){
   
Fiş takılı değilse fişi tak.

}else if(kumandanın pili bitmiş){

Kumandanın pili bittiyse değiştir.

}else if(kablolar mı çıkmış){

Kabloları yerine tak

}else{

Bunların hiç biri değilse sevisi çağır.

}

Yukarıdaki örnekte if, else if ve else anahtar kelimelerini görmüşsünüzdür. Şimdi bu yapıları karşılaştırma operatörleri ile kullanalım.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        int sayi1 = 10;
        int sayi2 = 5;

        if (sayi1 > sayi2)
        {

            Debug.Log("sayi1, sayi2'den büyüktür.");

        }
        else 
        {

            Debug.Log("sayi1, sayi2'den küçüktür.");

        }
    }
}

Sonuç: sayi1, sayi2’den büyüktür.

Yukarıdaki örnekte sayi1 ve sayi2 isminde iki adet değişken oluşturduk ve if-else bloğuna soktuk. if içerisinde yer alan sayi1 > sayi2 (sayı1 büyüktür sayi2) koşulu sağlandığı için if bloğunun içerisine girdi ve süslü parantezlerin içinde yazdığımız kodu çalıştırdı.

Eğer sayi1, sayi2 den küçük olsaydı else bloğunun içine girecektir. Yani if() içerisinde tanımlı olan koşul geçerli olursa if süslü parantezleri içinde geçerli değilse else süslü parantezleri içine girecektir.

Burada if bloğunun içine girmesi için parantezler içinde yazan karşılaştırmanın doğru olması gerekiyor. Peki birden fazla karşılaştırma yapmamız gereken durumlarda ne yapıyoruz? İşte burada else if mantığı devreye gidiyor.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        int ahmetYas = 30;
        int mehmetYas = 20;
        int yeldaYas = 25;

        if (ahmetYas < mehmetYas)
        {

            Debug.Log("Ahmet'in yaşı, Mehmet'in yaşından küçüktür.");

        }
        else if (ahmetYas < yeldaYas)
        {

            Debug.Log("Ahmet'in yaşı, Yelda'nın yaşından küçüktür.");

        }
        else 
        {

            Debug.Log("Ahmet'in yaşı, Yelda ve Mehmet'in yaşından büyüktür.");

        }
    }
}

Sonuç: Ahmet’in yaşı, Yelda ve Mehmet’in yaşından büyüktür.

Yukarıda else else-if ve else üçlüsünün bir arada kullanıldığı bir yapı örneği verdim.

Burada ilk if bloğu doğru olmadığı için çalışmadı, sonrasında else if bloğunu kontrol etti ve yine doğrulamadığı için else bloğu içinde sonucu ekrana bastırdı.

İşin özeti birden fazla kontrol yapmanız gereken durumlarda else if kullanabilirsiniz. if … else yapısında istediğiniz kadar else if(){} ekleyebilirsiniz ama birer adet if(){} ve else{} yazabilirsiniz.

Son bir örnek vererek if .. else yapısını sonlandıracağım ama bu sefer daha zor bir örnek olsun.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        int aKarakteriGucu = 2;
        int bKarakteriGucu = 10;
        int cKarakteriGucu = 10;

        if (aKarakteriGucu == bKarakteriGucu)
        {

            Debug.Log("A ve B karakterlerinin gücü eşittir.");

        }
        else if (bKarakteriGucu > aKarakteriGucu && bKarakteriGucu > cKarakteriGucu)
        {

            Debug.Log("B karakteri en güçlüdür.");

        }
        else if (bKarakteriGucu != aKarakteriGucu)
        {

            Debug.Log("B ve A karakterlerinin gücü aynı değildir.");

        }
        else if (cKarakteriGucu == aKarakteriGucu)
        {

            Debug.Log("C ve A karakterlerinin gücü aynıdır.");

        }
        else{

            Debug.Log("Doğru sonuç bulunamamıştır.");
        }
    }
}

Şimdi yukarıdaki koda baktığınızda else if (bKarakteriGucu != aKarakteriGucu) ve else if (cKarakteriGucu == aKarakteriGucu) kısımlarının doğru olduğunu göreceğiz. Peki bu durumda hangisini çalıştıracak?

Sonuç: “B ve A karakterlerinin gücü aynı değildir.”

Böyle bir durumda her zaman ilk doğru olan çalışacaktır. Eğer koşullardan bir doğru olursa diğer koşullara geçmeden çalışmayı sonlandıracağını bilmeliyiz.

Eğer bu kod yukarıdaki gibi olsaydı her ikisini de çalıştıracaktı. Çünkü her if bloğu kendi içinde başlar ve biter. Yani birinci if bloğunu çalıştırdı, doğruladı ve sonucu yazdı. Sonrasında ikinci çalıştırdı, doğruladı ve sonucu yazdı.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        int aKarakteriGucu = 2;
        int bKarakteriGucu = 10;
        int cKarakteriGucu = 10;

        if (aKarakteriGucu != bKarakteriGucu)
        {

            Debug.Log("A ve B karakterlerinin gücü eşit değildir.");

        }
        
        if (bKarakteriGucu == cKarakteriGucu)
        {

            Debug.Log("B ve C karakterlerinin gücü eşittir.");

        }
        
    }
}

Sonuç: “A ve B karakterlerinin gücü eşit değildir.” ve “B ve C karakterlerinin gücü eşittir.”

For Döngüsü

Programlama dilleri arasında en çok kullanılan yapılardan biride for döngüleridir. For döngüleri sayesinde belirtilen koşul sağlanana kadar istenilen komutları bir döngüye sokarak çalıştırabiliriz. Yani belli bir işlemi belli bir sayıda gerçekleştirebiliriz.

Yazım kalıbı aşağıdaki gibidir.

for(başlangıç değeri; koşul; değişim miktarı)
{
çalıştırılacak komut
}

Şimdi küçük bir örnek yapalım. Örneğin ekrana 5 kere “Birlikte Öğreniyoruz” yazdırmak istiyoruz. Bunun için 5 kere aynı kodu yazmamız hem kod kalabalıklığı hem de bize iş yükü olacaktır. Tabi bir de bu sayının 5 değilde 500 olduğunu düşünün.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        for (int sayi = 0; sayi < 5; sayi++)
        {
            Debug.Log("Birlikte Öğreniyoruz - " + "Sayı: " + sayi );
        }
        
    }
}

Yukarıda belirttiğimiz gibi for döngüsü içerisinde int sayi = 0 şeklinde bir başlangıç değeri atıyoruz. Burada önceden gördüğümüz gibi bir Integer değişken oluşturduk ve değer atadık. Böylece döngünün başlangıç sayısını belirtmiş oluyoruz.

İkinci kısım yani sayi < 5 yazarak ise, oluşturduğumuz sayı değişkeninin hangi değere kadar devam edeceğini belirledik. Son aşamada yazdığımız sayi++ ile her döngü sonunda sayı değişkenini bir arttırıyoruz.

sayi değişkeni her arttığında for değişkeninin süslü parantezi içine eklediğiniz kod bloğu çalışacaktır. Örneğin süslü parantez içine i sayısının kaç olduğunu bastırdığımız da aşağıdaki gibi bir çıktı alacağız. Çok farklı for döngüleri kullanımları var ama merak etmeyin ileri ki süreçte çokça örnek yapacağız.

Bu arada sayi++ kısmını ilk defa gördünüz, buna da kısaca bir değinelim.

Eğer değişkenin sonunda sayi++ ya da sayi– varsa önce kullandığınız kod çalışır ve sonrasında değişkeni arttırır ya da azaltır.

Eğer değişkenin başında ++sayi ya da –sayi varsa önce değişkeni arttırır ya da azaltır ve sonrasında kod çalışır.

Foreach Döngüsü

Foreach döngüleri for döngülerinin liste ve dizilerle kullanılan versiyonu diye düşünebilirsiniz. for döngülerinde bir değişken tanımlayarak değişkenin değerine göre işlem yapıyorduk. Foreach döngüsüyle ise listeler ve diziler içinde gezerek işlem yapabiliyoruz. Biliyorum karışık oldu biraz o yüzden yazım kalıbına ve örneklere geçelim.

Yazının önceki kısımlarında array yani listeler konusunda nasıl bir liste oluşturacağımıza değinmiştik. Elimizde renkler şeklinde bir liste olduğunu düşünelim.

string[] renkler = { "siyah", "beyaz", "kırmızı", "mavi", "sarı" };

Şimdi bu listenin içindeki elemanlara tek tek erişerek ekrana yazdırmak için bir foreach döngüsü oluşturalım.

 foreach (var eleman in renkler)
  {
    Debug.Log(eleman);
  }

var eleman in renkler kalıbında oluşturduğumuz listeyi foreach döngüsüne tanımladık. Burada belirtilen var eleman in kısmı foreach döngüleri için bir kalıptır. Siz isterseniz burada ki eleman ismini değiştirebilirsiniz.

Döngünün amacı renkler listesinde yer alan her değeri sırasıyla “elaman” yapısına aktarır. Biz burada array içindeki her değerini log ekranına bastırdık ama bunu daha kapsamlı düşünebilirsiniz. Örneğin çıkan her sonuçta işlemler yapıldığını ya da belirli bir sonuca göre farklı bir sürecin başladığını düşünebilirsiniz. İleride mobil oyun yapmak için çokça kullanacağımız yapılardan olduğu için farklı çeşitlerini detaylıca inceleyeceğiz.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        string[] renkler = { "siyah", "beyaz", "kırmızı", "mavi", "sarı" };

        foreach (var eleman in renkler)
        {
            Debug.Log(eleman);
        }
    }
}

While ve Do-While Döngüsü

Belirlediğimiz koşul gerçekleşene kadar çalışan döngü yapılarıdır. Fakat While ve Do While döngüleri arasında çalışma mantığı bakımından kritik bir fark bulunmaktadır. Şuan çalıştığım şirkette en çok kullandığımız yapılardan biri olduğu ve unity ile oyun programlama aşamasında da sıkça karşılaşacağımız için mantığını ve aralarındaki farkı anlamanızın önemli olduğunu söyleyebilirim.

While Döngüsü

While döngüsünde belirlediğimiz koşul sağlandığı sürece belirlediğimiz kodları çalışmak için kullanırız. Do-While arasındaki farkı koşul gerçekleşmediği sürece çalışmaz.

Yazım kalıbı aşağıdaki gibidir.

while (koşul)
{
çalışacak kod
}

Bir örnek vererek pekiştirmeye çalışalım.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {
        int sayi = 5;

        while (sayi < 10)
        {
            Debug.Log("Sayı şuan: " + sayi);
            sayi++;
        }

    }
}

Yukarıda ki örnekte int sayi = 5; ile sayı isminde Integer bir değişken oluşturduk ve 5 değerini atadık. While bloğunun içine koşul olarak while (sayi < 10) şeklinde yazarak sayi değeri 10’dan küçük olduğu sürece döngüye girmesini söyledik.

Son olarak çalışacak kod kısmına ise Unity console ekranına basması için log bastık ve her döngüye girdiğinde sayi değerinin artması için sayi++ tanımlamasını yaptık.

Sayi değişkeni her döngüye girdiğinde bir artacaktır ve kural geçerli olmayana kadar çalışacaktır. Burada eğer sayı değişkenini her döngüye girdiğinde sayi++ şeklide artırmasaydık tahmin edebileceğiniz üzere sürekli aynı döngüye girecekti. Bu durumda yazdığınız kod loopa girecektir ve unity oyun motoru kilitlenecektir. Bu sebeple her iki döngüde de loop durumuna dikkat etmeniz gerekecektir.

Do – While Döngüsü

do-while döngüsünde ise belirtilen koşul gerçekleşip gerçekleşmediğine bakmaksızın bir kereye mahsus çalışacaktır. Sonrasında ise belirtilen kural gerçekleştiği sürece çalışmaya devam edecektir.

Şimdi bir örnekle hem yazım kalıbını öğrenelim hem de kafamızda biraz daha yapının oturmasını sağlayalım.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {

        int sayi = 11;

        do
        {
            Debug.Log("Sayı: " + sayi);
            i++;                 

        } while (sayi<10);

    }
}

While döngüsündeki örneğin benzerini Do-While içinde gerçekleştirdik. Yine aynı şekilde int sayi = 11; bir Integer değişken oluşturduk ve while (sayi<10); sayi değişkeni 10’dan küçükse do-while döngüsüne girmesini belirttik.

Ama gördüğünüz üzere burada sayi değişkenine 11 atandığı için ve kural ise 10’dan küçük olduğu için döngünün kuralını gerçekleştiremiyor. Fakat do-while döngüsünün özelliği kurala uyup, uymamasına bakmadan bir kere çalıştırdığı için sonuç aşağıdaki gibi olacaktır. Bir kere çalışma işleminden sonra kurala uyarsa da normal while döngüsü gibi kurala uymayana kadar çalışmaya devam edecektir.

Sonuç: Sayı: 11

Switch Case Yapısı

Switch Case yapısı genellikle belirli bir koşula dönecek olan farlı karar yapılarında kullanılan yapılardır. Evet biraz karışık bir tabir oldu. O yüzden şöyle bir örnek vereceğim. 1-10 arasındaki sayıları bir kağıda yazarak bir sepetin için attık ve her seçimimizde çıkan numaraya göre farklı hediyeler kazanıyoruz. Gerçek hayatta ki bu örneği programlama dünyasında gerçekleştirmek için kullanabileceğiniz yapılardan biri switch-case yapısıdır.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {

        int tahminEdilenSayi = 8;

        switch (tahminEdilenSayi)
        {
            case 1:
                Debug.Log("Saat Kazandınız");
                break;

            case 4:
                Debug.Log("Araba Kazandınız");
                break;

            case 8:
                Debug.Log("Ev Kazandınız");
                break;

            case 10:
                Debug.Log("Bilgisayar Kazandınız");
                break;

            default:
                Debug.Log("Herhangi bir ödül kazanamadınız.");
                break;
        }
    }
}

Örnekteki görüldüğü int tahminEdilenSayi = 8; tanımlamasıyla bir Integer değişken oluşturarak 8 sayısını atadık. Bu sayısı kullanıcıdan aldığımız tahmin olarak düşünebilirsiniz.

switch (tahminEdilenSayi) kısmında bu yapı için geçerli olacak değişkeni atadık. Yani kullanıcının cevabını aktarıyoruz ve aşağıdaki case 1: , case 4 : gibi seçeneklerle kullanıcıdan gelen cevapları teyit ediyoruz.

Yani kullanıcının cevabı 1 ise case 4: olan kısımdaki kodlar çalışsın eğer cevap 10 ise case 10: olan kısımdaki cevaplar çalışsın demiş oluyoruz.

Şimdi örnekte kullanıcının 8 numaralı cevabı verdiğini tanımladığımız için unity console ekranına bastırmak için Debug.Log("Ev Kazandınız") komutu çalışacaktır.

Örnekte 1,4,8 ve 10 sayıları için tanımlama yaptığımız için eğer bu sayılardan farklı bir atama yaparsak default: kısmındaki komutlar çalışır. Yani bir switch-case yapısında koşul olarak belirtilmeyen bir durum gerçekleşirse default: alanı devreye girmektedir.

Her case yapısının sonunda gördüğünüz break; komutu ise eğer koşulun sağlanması durumunda eklenmesi zorunlu olan bir anahtar kelimedir. Eğer kullanıcı 1 seçimini yaparsa case 1: çalışır ve switch-case yapısı sonlanır.

Ayıca aşağıdaki gibi birden fazla seçim için de aynı kodları da çalıştırabilirsiniz.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {

        int tahminEdilenSayi = 8;

        switch (tahminEdilenSayi)
        {
            case 1:
                Debug.Log("Saat Kazandınız");
                break;

            case 4:
                Debug.Log("Araba Kazandınız");
                break;

            case 8:
            case 9:
            case 2:

                Debug.Log("Ev Kazandınız");
                break;

            case 10:
                Debug.Log("Bilgisayar Kazandınız");
                break;

            default:
                Debug.Log("Herhangi bir ödül kazanamadınız.");
                break;
        }
    }
}

[

List Kullanımı

C#’nın sitesinde ArrayList’lerin kullanılmasının artık tavsiye edilmediği bilgisi yazıldığı için sadece list yapılarına değineceğim.

List aslında bir C# sınıfı olup .Net tarafından, nesneleri bir liste sınıfı olarak gösterilmesi için özel olarak tasarlanmıştır. Dizilerde olduğu gibi içerisindeki elemanlara index numaralarıyla erişebiliriz ve ekleme, çıkarma, temizleme, arama gibi bir çok kendine özgü metodu bulunmaktadır.

List<string> sehirler = new List<string>(); şeklinde bir yazım kalıbı bulunmaktadır. List anahtar kelimesi ve örnekte string olarak belirttiğimiz gibi içerisine ekleyeceğimiz değişken türü belirtilir. Son olarak new anahtar kelimesiyle(nesne oluşturma) list yapısı oluşturulur.

Listeye Eleman Ekleme

Bir listeye eleman eklemek için Add metodu kullanılır. Önceden oluşturduğunuz sehirler listesine sehirler.Add(“İstanbul”); komutuyla yeni eleman ekleyebilirsiniz. Eğer eleman sayısının belli olduğu durumlar varsa Array yani dizileri daha az yer kapladığı ve daha performanslı olduğu için tercih edebilirsiniz. Ama örneğimizdeki gibi elemanlar belli değilse ve sonradan ekleme yapacaksak list yapısını kullanabilirsiniz.

public class TemelCDersleri : MonoBehaviour
{
    void Start()
    {

        List<string> sehirler = new List<string>();
        sehirler.Add("İstanbul");
        sehirler.Add("Artvin");

    }
}

List Eleman Sayısını Öğrenme

Bir listenin eleman sayısını öğrenmek için .Count anahtar kelimesini yani metodunu kullanabilirsiniz.

Aşağıdaki örnekteki gibi şehirler listesi oluşturduk ve eleman eklemesi yaptıktan sonra sehirler.Count komutuyla unity console ekranına log bastık.

Bu arada belirtmeden geçemeyeceğim. Örneğin bir çok örnek için Debug.Log ile console ekranına bastırarak görmeye çalışıyoruz. Ama programlama yaparken neredeyse bu şekilde hiç kullanmayıp bu örnekleri direk kod yapısının içinde kullanacağız. Örneğin bir for fonksiyonunun içinde boyut belirtirken ya da bir if fonksiyonunda kural olarak tanımlama gibi.

 void Start()
    {

        List<string> sehirler = new List<string>();
        sehirler.Add("İstanbul");
        sehirler.Add("Artvin");
        sehirler.Add("İzmir");
        Debug.Log(sehirler.Count);

    }

Sonuç: 3

List Elemanlarına Erişme

List elemanlarına erişme işlemi daha önceden diziler konusunda değindiğimiz gibi köşeli parantezler arasına erişmek istediğimiz index numarasını yazarak yapacağız. Tabi index numaralarının 1’den değilde 0’dan başladığını unutmayın.

void Start()
    {

        List<string> sehirler = new List<string>();
        sehirler.Add("İstanbul");
        sehirler.Add("Artvin");
        sehirler.Add("İzmir");
        Debug.Log(sehirler[1]);

    }

Sonuç: Artvin

Belirli List Index Numarasına Eleman Ekleme

Listelere eleman eklemek için .Add metodu kullandığımızı belirtmiştik. Fakat her zaman listenin en sonuna ekleme yapmaktadır. Eğer listenin belirli bir index numarasına ekleme yapmak isterseniz .Insert sınıfını kullanabilirsiniz.

sehirler.Insert(0,"Ankara") yazarak sehirler listesinin ilk sırasına eleman ekleyebilirsiniz. Sıfır olarak belirilen rakam ile hangi index numarasına ekleyeneceğini belirtiyoruz.

void Start()
    {

        List<string> sehirler = new List<string>();
        sehirler.Add("İstanbul");
        sehirler.Add("Artvin");
        sehirler.Add("İzmir");
        sehirler.Insert(0,"Ankara");

    }

Sonuç: Ankara, İstanbul, Artvin, İzmir

List Elemanı Silme

Bir liste içinde yer alan elemanlardan birini silmek istiyorsanız .Remove sınıfını kullanabilirsiniz.

Aşağıdaki örnekte olduğu gibi Liste içerisinde yer alan “İzmir” elemanını silmesini belirttiğimiz gibi belirli elemanları silmesini söyleyebiliriz.

void Start()
    {

        List<string> sehirler = new List<string>();
        sehirler.Add("İstanbul");
        sehirler.Add("Artvin");
        sehirler.Add("İzmir");
        sehirler.Remove("İzmir");

    }

Sonuç: İstanbul, Artvin

List Tüm Elemanları Silme, Boşaltma

Bir listeyi tamamen temizlemek yani içerisini silmek için .Clear metodu kullanılır. Bu şekilde liste içinde yer alan tüm elemanlar silinecektir.

 void Start()
    {

        List<string> sehirler = new List<string>();
        sehirler.Add("İstanbul");
        sehirler.Add("Artvin");
        sehirler.Add("İzmir");
        sehirler.Clear();

    }

Sıradaki dersimizde C# için fonksiyon, sınıf ve erişim belirleyiciler gibi kavramları öğrendikten sonra Unity Oyun Motorunun temel fonksiyonlarına geçiş yapacağız.

Unity Fonksiyonlar ve Sınıflar