C# ile Değişkenler ve Veri Tipleri

Merhaba değerli Webkolog.net takipçileri, bugünkü yazımızda C# programlama dilinin temel taşlarından biri olan değişkenleri ve veri tiplerini yakından inceleyeceğiz. Uygulamalarımızın yapı taşı olan bu kavramlar, verileri bellekte nasıl sakladığımızı ve işlediğimizi belirler. .NET Framework 4 çatısı altında C#'ta değişkenlerin dünyasına gelin birlikte dalalım!

Değişken Kavramı

Tıpkı matematikteki değişkenler gibi, C#'taki değişkenler de programımızın yürütülmesi sırasında değerleri saklamak için kullandığımız isimlendirilmiş bellek alanlarıdır. Bir değişken tanımladığımızda, bellekte belirli bir boyutta bir yer ayrılır ve bu alana atadığımız değer, değişkenin o anki içeriğini oluşturur. Bu değer, programın akışı içerisinde değişebilir, bu yüzden "değişken" adını alır.

Veri Tiplerinin Sınıflandırılması

C#'ta veri tipleri temel olarak iki ana kategoriye ayrılır: basit (değer) tipler ve karmaşık (referans) tipler. Bu ayrım, verilerin bellekte nasıl saklandığı ve işlendiği açısından kritik bir öneme sahiptir.

Basit (Değer) Tipler

Değer tipleri, değişkenin doğrudan değerini içerir ve bu değer belleğin Stack adı verilen bölgesinde saklanır. Bir değer tipindeki değişkeni başka bir değişkene atadığımızda, değerin bir kopyası oluşturulur. Bu nedenle, kopyalanan değişkendeki bir değişiklik, orijinal değişkeni etkilemez.

Basit tipler kendi içinde de alt kategorilere ayrılır:

• Sayısal Tipler: Tam sayıları (byte, short, int, long, sbyte, ushort, uint, ulong) ve ondalıklı sayıları (float, double, decimal) içerir.
• Karakter Tipi: Tek bir Unicode karakterini temsil eden char tipidir.
• Mantıksal Tip: true veya false olmak üzere iki değer alabilen bool tipidir.
• Yapısal Tipler (Struct): Birden fazla farklı tipteki değişkeni bir arada tutabilen değer tipleridir.
• Numaralandırma Tipleri (Enum): Adlandırılmış sabit değerler kümesini tanımlamak için kullanılır.

Karmaşık (Referans) Tipler

Referans tipleri ise değişkenin doğrudan değerini değil, değerin bellekteki adresini (referansını) saklar. Bu değerler genellikle belleğin Heap adı verilen bölgesinde tutulur. Bir referans tipindeki değişkeni başka bir değişkene atadığımızda, aslında değerin kopyası değil, aynı bellek adresini işaret eden bir referans kopyalanır. Bu durumda, her iki değişken de aynı bellek alanını gösterdiği için, birinde yapılan değişiklik diğerini de etkiler.

Referans tiplerine örnek olarak şunları verebiliriz:

• Sınıflar (Class): Nesne yönelimli programlamanın temelini oluşturan yapılardır.
• Arayüzler (Interface): Sınıfların uygulaması gereken bir sözleşmeyi tanımlar.
• Diziler (Array): Aynı türden birden fazla öğeyi sıralı bir şekilde saklamak için kullanılır.
• Dizeler (String): Metinsel verileri temsil eder.
• Nesne Tipi (Object): Tüm diğer tiplerin temel sınıfıdır ve herhangi bir türden değeri alabilir.
• Dinamik Tip (Dynamic): Derleme zamanında tür kontrolü yapılmayan bir tiptir.

Bellek Yönetimi Açısından Farklar:

Değer tipleri Stack'te hızlı bir şekilde oluşturulup yok edilirken, referans tipleri Heap'te daha karmaşık bir bellek yönetimi sürecine tabidir. Heap üzerindeki nesnelerin ne zaman serbest bırakılacağını .NET'in otomatik bellek yönetimi (Garbage Collection) mekanizması belirler. Heap üzerindeki işlemlerin Stack üzerindeki işlemlere göre daha yavaş olması da bu karmaşık yapıdan kaynaklanır.

RAM
-------------------------     ----------------------
|  Stack                 |     |  Heap                |
|  ---------------------  |     |                     |
| |   Değer Tipleri     | |     |                     |
|  ---------------------  |     |                     |
|  ---------------------  |     |  ------------------  |
| | Referans Tiplerinin | | ==> | | Referans Tipleri | |
| |        Adresi       | |     |  ------------------  |
|  ---------------------  |     |                     |
-------------------------     ----------------------

Temel Değer ve Referans Tipleri

Aşağıda C# .NET Framework 4'te en sık kullanılan değer ve referans tiplerinin bir listesi ve kısa açıklamaları bulunmaktadır:

Değer Tipleri:

Tür	.NET Yolu	Açıklama
bool	System.Boolean	true veya false değerlerini alır.
byte	System.Byte	0 ile 255 arasında işaretsiz tam sayı değerlerini alır.
sbyte	System.SByte	-128 ile 127 arasında işaretli tam sayı değerlerini alır.
char	System.Char	Tek bir Unicode karakterini temsil eder (0 ile 65535 arası tam sayı).
decimal	System.Decimal	Yüksek duyarlıklı ondalık sayıları temsil eder (finansal işlemler için ideal).
double	System.Double	Çift duyarlıklı kayan noktalı sayıları temsil eder.
float	System.Single	Tek duyarlıklı kayan noktalı sayıları temsil eder.
int	System.Int32	-2,147,483,648 ile 2,147,483,647 arasında işaretli tam sayıları alır.
uint	System.UInt32	0 ile 4,294,967,295 arasında işaretsiz tam sayıları alır.
long	System.Int64	-9 x 10¹⁸ ile 9 x 10¹⁸ arasında işaretli tam sayıları alır.
ulong	System.UInt64	0 ile 18 x 10¹⁸ arasında işaretsiz tam sayıları alır.
short	System.Int16	-32,768 ile 32,767 arasında işaretli tam sayıları alır.
ushort	System.UInt16	0 ile 65,535 arasında işaretsiz tam sayıları alır.
enum	System.Enum	Adlandırılmış sabit değerler kümesini tanımlar.
struct	System.ValueType	Birden fazla farklı tipteki değişkeni bir arada tutan yapısal tiptir.

Referans Tipleri:

Tür	.NET Yolu	Açıklama
string	System.String	Metinsel verileri temsil eder.
class	System.Object	Nesnelerin oluşturulduğu temel yapıdır.
object	System.Object	Tüm diğer tiplerin temel sınıfıdır, herhangi bir türden değeri alabilir.
array	System.Array	Aynı türden birden fazla öğeyi sıralı bir şekilde saklar.
interface	System.Interface	Sınıfların uygulaması gereken bir sözleşmeyi tanımlar.
delegate	System.Delegate	Metotlara referans tutmak için kullanılır.

Önemli Not: object tipi, tüm diğer tiplerin atasıdır. Bu, herhangi bir türdeki bir değeri bir object türündeki değişkene atayabileceğimiz anlamına gelir.

Değişken Tanımlama Kuralları

C#'ta değişken tanımlarken uymamız gereken bazı kurallar vardır:

• Değişken isimleri Türkçe karakter içeremez.
• C#'a özgü anahtar kelimeler (örneğin if, else, for, foreach, while, switch, do vb.) değişken adı olarak kullanılamaz.
• Değişken isimleri bir sayı ile başlayamaz.
• Değişken isimleri arasında boşluk olamaz (ayrı iki kelime şeklinde yazılamaz).

Ancak, değişken isimlerinde şunlara izin verilir:

• Harfler (a-z, A-Z)
• Rakamlar (0-9)
• Alt çizgi (_)

Unutmayın: C# büyük-küçük harf duyarlı bir dildir. Bu nedenle degiskenAdi ve DegiskenAdi farklı değişkenlerdir.

Değişken Tanımlama Söz Dizimi

Bir değişkeni tanımlamanın temel söz dizimi şöyledir:

veriTipi değişkenAdı = değişkenDeğeri;

Örneğin:

string mesaj = "Merhaba Dünya!";
int sayi = 10;
bool aktifMi = true;
double piSayisi = 3.14;

Değişken İsimlendirme Konvansiyonları

Kodun okunabilirliğini artırmak için yaygın olarak kullanılan bazı değişken isimlendirme konvansiyonları vardır:

• Pascal Case (DegiskenAdi): Her kelimenin ilk harfi büyük yazılır. Genellikle sınıf, metot ve özellik isimlerinde kullanılır.
• Camel Case (degiskenAdi): İlk kelimenin ilk harfi küçük, sonraki her kelimenin ilk harfi büyük yazılır. Genellikle yerel değişken isimlerinde kullanılır.
• Underscore Case (degisken_adi): Kelimeler alt çizgi ile ayrılır ve genellikle tamamı küçük harflerle yazılır. Bazı durumlarda (özellikle özel alanlarda) kullanılabilir.

Global ve Yerel Değişkenler

Değişkenlerin erişilebilirlik kapsamı (scope), nerede tanımlandıklarına bağlıdır:

• Yerel Değişkenler (Local Variables): Bir metot (method) veya bir kod bloğu içinde tanımlanan değişkenlerdir. Bu değişkenlere yalnızca tanımlandıkları metot veya blok içinden erişilebilir. Bir kod bloğunun işlevi sona erdiğinde, o blok için ayrılan bellek alanı serbest bırakılır ve bu değişkenlere dışarıdan erişim mümkün olmaz. Yerel değişkenlere bir değer atanması zorunludur.
• Global Değişkenler (Global Variables) / Alanlar (Fields): Bir sınıf (class) seviyesinde, metotların dışında tanımlanan değişkenlerdir. Bu değişkenlere, tanımlandıkları sınıfın tüm metotlarından erişilebilir. Global değişkenlere başlangıçta bir değer atanmayabilir; bu durumda varsayılan bir değere sahip olurlar (sayısal tipler için 0, boolean için false, referans tipler için null gibi).

String Kaçış Karakterleri

string ifadeleri içinde özel anlamları olan bazı kaçış karakterleri kullanılır:

Kaçış Karakteri	Üretilen Değer	Unicode Karşılığı
\'	Tek tırnak	0x0027
\"	Çift tırnak	0x0022
\\	Sola eğik çizgi	0x005C
\b	Geri al (Backspace)	0x0008
\n	Yeni satır	0x000A
\r	Satır başı	0x000D
\t	Sekme (Tab)	0x0009
\a	Zil sesi (Alert)
\f	Form besleme
\v	Dikey sekme
\?	Soru işareti
\xhh..	16'lık karakter
\uhhhh	Unicode karakter

Ayrıca, @ sembolü ile başlayan string literal'leri (verbatim string literals) kaçış karakterlerini yorumlamaz. Bu özellikle dosya yolları gibi ters eğik çizgi (\) içeren metinleri tanımlarken oldukça kullanışlıdır. Normal bir string literal'inde ters eğik çizgiyi kullanmak için çift ters eğik çizgi (\\) yazmanız gerekirken, verbatim string literal'lerinde tek ters eğik çizgi yeterlidir.

Verbatim String Literal Örneği:

string dosyaYoluNormal = "C:\\Users\\Kullanici\\Belgeler\\dosya.txt";
string dosyaYoluVerbatim = @"C:\Users\Kullanici\Belgeler\dosya.txt";

Console.WriteLine(dosyaYoluNormal);     // Çıktı: C:\Users\Kullanici\Belgeler\dosya.txt
Console.WriteLine(dosyaYoluVerbatim);   // Çıktı: C:\Users\Kullanici\Belgeler\dosya.txt

string cokSatirliMetin = @"Bu bir
çok satırlı
metindir.";

Console.WriteLine(cokSatirliMetin);
/* Çıktı:
Bu bir
çok satırlı
metindir.
*/

Gördüğünüz gibi, @ sembolü ile başlayan string literal'lerinde ters eğik çizgiler özel bir anlam taşımaz ve olduğu gibi kabul edilir. Ayrıca, verbatim string literal'leri birden fazla satıra yayılan metinleri tanımlamak için de kolaylık sağlar.

---

Evet sevgili Webkolog.net okurları, bu yazımızda C# .NET Framework 4 dünyasına yaptığımız bu ilk adımda, temel kavramları ve teknik terimleri Visual Studio 2010 özelinde ele almaya çalıştım. Umarım bu giriş yazısı, bu heyecan verici platforma olan ilginizi artırmış ve size yol göstermiştir. Bir sonraki yazımda, C# dilinin diğer önemli yapı taşlarını keşfetmeye devam edeceğiz. Webkolog.net'i takipte kalın!

Hepinize bol kodlu ve keyifli öğrenme süreçleri dilerim!