C# Record, Class ve Struct: Kapsamlı Rehber ve Farklar

C# geliştiricileri için Record, Class ve Struct arasındaki temel farkları, ne zaman hangisini kullanmanız gerektiğini ve performans ipuçlarını bu kapsamlı rehberde keşfedin. Bu üç farklı veri modelleme yaklaşımı, uygulamanızın performansını, bellek kullanımını ve kodun sürdürülebilirliğini doğrudan etkileyebilir.

Modern C# uygulamaları geliştirirken, veri modellerinizi nasıl tanımlayacağınız konusunda karşınıza üç ana seçenek çıkar: class, struct ve record. Her birinin kendine özgü avantajları, dezavantajları ve kullanım senaryoları bulunur. Doğru seçimi yapmak, projenizin ölçeklenebilirliği, performansı ve hatta hata ayıklama süreçleri için kritik öneme sahiptir. Peki, bu seçenekler arasında ne gibi farklılıklar var ve en uygun kararı nasıl verebiliriz? Bu makalede, bu soruların cevaplarını detaylı örnekler ve gerçek dünya senaryolarıyla adım adım inceleyeceğiz. Gelin, C#’taki veri modelleme dünyasına birlikte dalalım!

C# programlama dilinde, veri tiplerini tanımlarken Class, Struct ve Record gibi farklı yapılar kullanırız. Ancak, bu yapıların her birinin bellekteki davranışları, performans karakteristikleri ve kullanım amaçları birbirinden oldukça farklıdır. Bu farkları anlamak, daha verimli, güvenli ve sürdürülebilir C# uygulamaları geliştirmek için hayati önem taşır. Yanlış bir seçim yapmak, uygulamanızın gereksiz yere yavaşlamasına, fazla bellek tüketmesine veya beklenmedik hatalara yol açabilir. Bu nedenle, her geliştiricinin bu üç temel yapı hakkında derinlemesine bilgi sahibi olması gerekir.

Temelde, class‘lar referans tipleridir ve nesne tabanlı programlamanın (OOP) temelini oluştururlar. Genellikle daha büyük, karmaşık veri yapıları ve davranışlar için kullanılırlar. Bellekte “heap” adı verilen bir alanda yaşarlar ve bir değişkene atandıklarında, aslında o nesnenin bellekteki adresini (referansını) tutarlar. Bu davranış, esneklik ve kalıtım gibi güçlü özellikler sağlarken, bellek yönetimi (garbage collection) açısından da bazı maliyetleri beraberinde getirebilir.

Diğer yandan, struct‘lar değer tipleridir. Genellikle daha küçük, basit veri yapıları için tasarlanmışlardır ve çoğunlukla “stack” bellekte tutulurlar. Bir struct bir değişkene atandığında veya bir fonksiyona parametre olarak geçtiğinde, verinin kendisi kopyalanır. Bu değer semantiği, küçük veri yapıları için daha hızlı erişim ve daha az çöp toplama yükü anlamına gelebilir. Ancak, büyük struct‘lar kullanmak, kopyalama maliyetleri nedeniyle performans düşüşlerine neden olabilir.

Son olarak, .NET 5 ile hayatımıza giren record‘lar, değişmez (immutable) veri tipleri oluşturmanın modern ve daha kolay bir yolunu sunar. Hem class hem de struct olarak tanımlanabilirler (record class veya record struct). Asıl gücü, değer tabanlı eşitlik karşılaştırması ve “non-destructive mutation” (with ifadesi ile yeni bir nesne oluşturma) gibi özellikleridir. record‘lar özellikle veri taşıma nesneleri (DTO’lar), yapılandırma ayarları veya herhangi bir değişmez veri modellemesi için idealdir. Bu sayede, daha güvenli ve öngörülebilir kod yazmak mümkün hale gelir. Bu yapıların her birini ne zaman ve nasıl kullanacağımızı bilmek, C# projelerimizde akıllıca kararlar vermemize olanak tanır.

C# Class Nedir ve Ne Zaman Kullanılmalıdır?

C# dilindeki class, nesne tabanlı programlamanın (OOP) temel yapı taşıdır. Bir class, genellikle karmaşık varlıkları, onların özelliklerini (properties) ve davranışlarını (methods) modellemek için kullanılır. En önemli özelliği, bir referans tipi olmasıdır. Bu, class‘ların bellekte heap bölgesinde ayrılan alanlarda saklandığı ve bir class türündeki değişkenin aslında bu bellek alanının adresini (referansını) tuttuğu anlamına gelir.

Referans tipi olmaları sayesinde, class‘lar kalıtım (inheritance) ve polimorfizm gibi OOP prensiplerini destekler. Yani, bir class başka bir class‘tan türeyebilir, onun özelliklerini ve metotlarını miras alabilir, hatta onları geçersiz kılabilir (override). Bu esneklik, geniş ve modüler uygulamalar geliştirmek için vazgeçilmezdir. Ayrıca, class örnekleri (nesneleri) varsayılan olarak null değerini alabilir, bu da bir nesnenin varlığını veya yokluğunu kontrol etme esnekliği sunar.

Class Kullanım Senaryoları ve Bir Vaka Analizi

class‘lar genellikle aşağıdaki durumlarda tercih edilir:

• Büyük ve Karmaşık Nesneler: Örneğin, bir e-ticaret uygulamasındaki Product, Customer, Order gibi varlıklar. Bu nesneler genellikle birden fazla özellik, karmaşık iş mantığı ve diğer nesnelerle ilişkiler içerir.
• Kalıtımın Gerektiği Durumlar: Ortak özelliklere sahip nesneler arasında bir hiyerarşi oluşturmak istediğinizde, örneğin Shape sınıfından türeyen Circle ve Rectangle sınıfları.
• Polimorfizm İhtiyacı: Farklı türdeki nesneleri tek bir arayüz üzerinden işlemek istediğinizde.
• Nesnelerin Referans ile Paylaşılması: Birden fazla kod parçasının aynı nesne üzerinde çalışmasını ve değişiklikleri yansıtmasını istediğinizde.

Vaka Analizi: E-ticaret Uygulamasında Ürün Yönetimi

Büyük bir e-ticaret uygulamasında, bir Product (Ürün) nesnesini modelleyelim. Bir ürünün adı, açıklaması, fiyatı, stok adedi gibi temel özelliklerinin yanı sıra, farklı varyantları (beden, renk), kategorileri, yorumları ve hatta tedarikçi bilgileri gibi karmaşık ilişkileri olabilir. Bu durumda, class kullanmak en mantıklı yaklaşımdır:

    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public decimal Price { get; set; }
        public int StockQuantity { get; set; }
        public Category ProductCategory { get; set; } // Başka bir Class
        public List Reviews { get; set; }    // Başka bir Class listesi

        public Product(int id, string name, decimal price)
        {
            Id = id;
            Name = name;
            Price = price;
            Reviews = new List();
        }

        public void ApplyDiscount(decimal percentage)
        {
            Price -= Price * (percentage / 100);
            Console.WriteLine($"{Name} için {percentage}% indirim uygulandı. Yeni fiyat: {Price}");
        }
    }

    public class Category
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    // Kullanım örneği
    var elektronikCategory = new Category { Id = 1, Name = "Elektronik" };
    var laptop = new Product(101, "Oyun Laptopu", 25000M)
    {
        Description = "Yüksek performanslı oyun bilgisayarı.",
        StockQuantity = 5,
        ProductCategory = elektronikCategory
    };
    laptop.ApplyDiscount(10);
    

Bu örnekte, Product sınıfı hem kendi özelliklerini hem de Category ve Review gibi diğer sınıflarla olan ilişkilerini yönetir. ApplyDiscount metodu ile ürüne özel bir davranış tanımlayabiliriz. Product nesnesi, bellekte bir referans olarak yaşar ve farklı fonksiyonlar veya bileşenler tarafından paylaşılabilir, bu da merkezi bir ürün bilgisi yönetimi sağlar.

C# Struct Nedir ve Hangi Durumlarda Tercih Edilmelidir?

C# dilindeki struct, class'ların aksine bir değer tipidir. Bu, struct örneklerinin doğrudan bellekteki veri değerini tuttuğu ve bir değişkene atandığında veya bir metoda parametre olarak geçtiğinde tüm verinin kopyalandığı anlamına gelir. Genellikle, struct'lar stack bellekte (küçük ve geçici veriler için kullanılan hızlı bellek bölgesi) veya bir nesnenin parçası olarak inline olarak tutulur. Bu değer semantiği, belirli senaryolarda class'lara göre önemli performans avantajları sağlayabilir.

struct'lar, basit ve küçük veri yapılarını temsil etmek için tasarlanmıştır. Örneğin, bir noktayı (x, y koordinatları), bir rengi (RGB değerleri) veya küçük bir zaman aralığını (saat, dakika, saniye) modellemek için idealdirler. struct'lar kalıtımı desteklemezler; yani başka bir struct'tan türeyemezler veya başka bir struct'ın temel tipi olamazlar (ancak arayüzleri uygulayabilirler). Ayrıca, struct'ların varsayılan constructor'ı parametresiz olamaz ve alanları doğrudan başlatılamaz; bu genellikle constructor aracılığıyla yapılır veya otomatik özellikler kullanılır.

Struct Kullanım Senaryoları ve Bir Vaka Analizi

struct'lar genellikle aşağıdaki durumlarda tercih edilir:

• Küçük Veri Yapıları: Bellekte çok az yer kaplayan ve sık sık kopyalanabilecek basit veri grupları için, örneğin Point, Color, DateTime.
• Performans Kritik Alanlar: Özellikle döngülerde veya çok sayıda küçük nesnenin oluşturulduğu durumlarda, struct'ların kopyalama ve çöp toplama maliyeti class'lara göre daha düşük olabilir.
• Değer Semantiği İstenildiğinde: Verinin kopyalanmasını ve bağımsız olarak işlenmesini istediğinizde, yani bir nesnenin "referansını" değil, "değerini" önemsediğinizde.
• Değişmezlik: struct'lar doğal olarak değişmez (immutable) olmaya yatkındır. Eğer tüm özellikleri readonly olarak tanımlanırsa, tamamen değişmez bir yapı elde edilebilir.

Vaka Analizi: Oyun Geliştirmede 2D Vektör Kullanımı

Bir oyun motorunda 2D koordinatları veya vektörleri temsil etmek için sıkça Vector2D gibi bir yapıya ihtiyaç duyulur. Bu tür yapılar oyun döngüsü boyunca binlerce kez oluşturulur, kopyalanır ve üzerinde işlem yapılır. Bu senaryoda struct kullanmak, performans açısından önemli avantajlar sağlar:

    public struct Vector2D
    {
        public float X { get; }
        public float Y { get; }

        public Vector2D(float x, float y)
        {
            X = x;
            Y = y;
        }

        public Vector2D Add(Vector2D other)
        {
            return new Vector2D(X + other.X, Y + other.Y);
        }

        public float Length()
        {
            return (float)Math.Sqrt(X * X + Y * Y);
        }

        public override string ToString()
        {
            return $"({X}, {Y})";
        }
    }

    // Kullanım örneği
    var pos1 = new Vector2D(10f, 20f);
    var pos2 = new Vector2D(5f, 7f);
    var newPos = pos1.Add(pos2); // pos1 ve pos2 kopyalanır, yeni bir Vector2D döner
    Console.WriteLine($"İlk pozisyon: {pos1}");
    Console.WriteLine($"Yeni pozisyon: {newPos}");
    Console.WriteLine($"Yeni pozisyon uzunluğu: {newPos.Length()}");
    

Bu örnekte, Vector2D bir struct olarak tanımlanmıştır. X ve Y özellikleri get; ile yalnızca okunabilir yapılmış, bu da Vector2D'yi değişmez kılar. Add metodu, yeni bir Vector2D döndürür, mevcut nesneyi değiştirmez. Bu davranış, özellikle çok iş parçacıklı ortamlarda veya sık sık geçici nesnelerle çalışılan durumlarda hataları azaltabilir. Kopyalama maliyeti, iki float değeri kopyalamak kadar düşük olduğu için performansı olumsuz etkilemez, aksine referans tabanlı bir sınıf kullanmaktan daha iyi olabilir.

Class ve Struct Arasındaki Temel Farklar Nelerdir?

Bu iki yapının farklı kullanım alanlarına sahip olmasının temel nedeni, bellekteki davranışlarıdır. İşte kritik farklar:

• Tip Kategorisi: Class referans tipidir, struct değer tipidir.
• Bellek Yeri: Class nesneleri heap'te, struct'lar genellikle stack'te veya içeren nesnenin içinde tutulur.
• Kopyalama Davranışı: Class atandığında veya metotlara geçtiğinde referans kopyalanır. Struct atandığında veya metotlara geçtiğinde verinin kendisi kopyalanır.
• Kalıtım: Class kalıtımı destekler, struct desteklemez (arayüzler hariç).
• Null Değer: Class null olabilir, struct varsayılan olarak null olamaz (Nullable ile mümkün).
• Çöp Toplama: Class nesneleri çöp toplayıcı tarafından yönetilir, struct'lar genellikle kapsam dışına çıktıklarında otomatik olarak temizlenir.

C# Record Nedir ve Modern Uygulamalarda Nasıl Bir Yer Edinmiştir?

.NET 5 ile birlikte C# dünyasına katılan record anahtar kelimesi, özellikle değişmez (immutable) veri modelleri oluşturmayı kolaylaştırmak için tasarlanmıştır. record'lar, hem record class (varsayılan) hem de record struct şeklinde tanımlanabilir, ancak yaygın olarak record class kullanımı amaçlanmıştır. record'ların temel amacı, veri odaklı tipler için daha kısa ve okunabilir bir sözdizimi sağlamak, değer tabanlı eşitlik karşılaştırması sunmak ve "non-destructive mutation" (var olan bir nesnenin kopyası üzerinde değişiklik yapma) yeteneği ile gelmektir.

Bir record'ın en belirgin özelliği, varsayılan olarak değer tabanlı eşitlik sağlamasıdır. Yani, iki record nesnesinin tüm özellikleri aynı değere sahipse, bunlar eşit kabul edilirler. Geleneksel class'larda ise referans tabanlı eşitlik kullanılır; iki nesnenin eşit olması için aynı bellek adresini işaret etmeleri gerekir. Bu fark, veri taşıma nesneleri (DTO'lar) veya yapılandırma nesneleri gibi değişmez veri modelleri için record'ları son derece kullanışlı kılar.

Ayrıca, record'lar, "with" ifadesi ile birlikte gelir. Bu ifade, mevcut bir record örneğinden yola çıkarak, bazı özelliklerini değiştirerek yeni bir record örneği oluşturmanızı sağlar. Bu, orijinal nesnenin değişmeden kalmasını garantilerken, kolayca varyasyonlar oluşturabilmenizi sağlar. Bu davranış, fonksiyonel programlama yaklaşımlarına da uyum sağlar.

Record Kullanım Senaryoları ve Bir Vaka Analizi

record'lar genellikle aşağıdaki durumlarda tercih edilir:

• Veri Taşıma Nesneleri (DTO'lar): API'lar arasında veri alışverişi yaparken, record'lar değişmez ve değer tabanlı eşitlik sayesinde çok kullanışlıdır.
• Yapılandırma Nesneleri: Uygulama ayarları gibi, bir kez yüklendikten sonra değişmesi beklenmeyen veriler için idealdir.
• Değişmez Veri Modelleri: Özellikle multi-threading ortamlarında veya bir nesnenin durumunun güvenli bir şekilde korunması gereken durumlarda.
• Basit Değer Objeleri: Sadece bir grup değeri kapsayan ve davranıştan ziyade veriye odaklanan tipler için.

Vaka Analizi: API Yanıtlarını Modelleme

Bir web API'sinden gelen kullanıcı bilgilerini temsil eden bir veri modelimiz olduğunu düşünelim. Bu verilerin alındıktan sonra genellikle değişmez olması ve basit bir şekilde karşılaştırılabilmesi istenir. record, bu senaryo için mükemmel bir çözümdür:

    public record UserProfile(int Id, string Username, string Email);

    // Kullanım örneği
    var user1 = new UserProfile(1, "ali.veli", "ali.veli@example.com");
    var user2 = new UserProfile(1, "ali.veli", "ali.veli@example.com");
    var user3 = new UserProfile(2, "ayse.fatma", "ayse.fatma@example.com");

    Console.WriteLine($"User1 ve User2 eşit mi? {user1 == user2}"); // True (Değer tabanlı eşitlik)
    Console.WriteLine($"User1 ve User3 eşit mi? {user1 == user3}"); // False

    // 'with' ifadesi ile yeni bir kopya oluşturma
    var updatedUser1 = user1 with { Email = "yeni.email@example.com" };
    Console.WriteLine($"Güncellenmiş Kullanıcı: {updatedUser1}");
    Console.WriteLine($"Orijinal Kullanıcı (değişmedi): {user1}");
    

Bu örnekte, UserProfile bir record olarak tanımlanmıştır. Id, Username ve Email özellikleri, constructor ile otomatik olarak atanır. Gördüğünüz gibi, user1 ve user2 aynı özellik değerlerine sahip oldukları için == operatörü true döner. Ayrıca, with ifadesi ile user1'in e-posta adresini değiştirerek updatedUser1 adında yepyeni bir record nesnesi oluşturulmuştur; orijinal user1 nesnesi ise değişmeden kalır. Bu sayede, değişmezlik prensibi korunur ve kodunuz daha güvenilir hale gelir.

Record, Class ve Struct Arasındaki Karşılaştırmalı Bir Analiz

Üç yapıyı da ayrı ayrı inceledikten sonra, temel farklılıklarını bir arada görmek, doğru seçimi yapmamıza yardımcı olacaktır. Bu karşılaştırma, performans, bellek yönetimi, kalıtım ve eşitlik gibi kritik faktörler üzerinden yapılacaktır.

Performans ve Bellek Yönetimi Açısından Hangisi Daha İyidir?

Performans ve bellek yönetimi açısından "en iyi" seçenek, kullanım senaryosuna göre değişir. Genel olarak:

• Struct: Küçük boyutlu ve sıkça oluşturulan nesneler için struct'lar, heap tahsisi ve çöp toplama maliyetinden kaçındıkları için daha iyi performans sunabilir. Ancak büyük struct'lar, kopyalama maliyeti nedeniyle performans düşüşlerine yol açabilir.
• Class: Büyük ve karmaşık nesneler için class'lar daha uygundur. Referansların kopyalanması, büyük verinin kendisinin kopyalanmasından daha ucuzdur. Ancak, çok sayıda kısa ömürlü class nesnesi oluşturmak, çöp toplayıcı üzerinde yük oluşturabilir.
• Record: Performans açısından record class'lar, standart class'larla benzer özelliklere sahiptir. record struct ise struct'larla benzer performans özellikleri gösterir ancak değişmezlik ve değer tabanlı eşitlik ekstraları sunar. with ifadesinin kullanılması, yeni nesne tahsisi anlamına gelir ve bu da dikkatli kullanılmalıdır.

Eşitlik Karşılaştırmalarında Nasıl Davranırlar?

• Class: Varsayılan olarak referans eşitliği sağlar. İki class nesnesi, aynı bellek adresini işaret ediyorlarsa eşittirler. İçerik eşitliğini sağlamak için Equals() metodunu veya == operatörünü override etmeniz gerekir.
• Struct: Varsayılan olarak değer eşitliği sağlar. İki struct nesnesinin tüm alanları aynı değere sahipse eşittirler. Bu, otomatik olarak Equals() metodunda ve == operatöründe uygulanır.
• Record: Otomatik olarak değer eşitliği sağlar. Tüm public özelliklerinin değerleri aynıysa, iki record nesnesi eşittir. Bu, Equals() metodu, GetHashCode() metodu ve == operatörü için otomatik olarak uygulanır. Bu, record'ları DTO'lar için mükemmel bir seçim yapar.

Gerçek Dünya Senaryolarında Doğru Seçimi Nasıl Yapmalıyız?

Doğru veri modelini seçmek, uygulamanızın kalitesi üzerinde büyük bir etkiye sahiptir. İşte bazı rehber ilkeler ve düşünülmesi gereken senaryolar:

Ne Zaman Class Kullanmalıyız?

class, C#’taki varsayılan ve en esnek veri modelleme seçeneğidir. Genellikle aşağıdaki durumlarda tercih edilir:

• Karmaşık İş Mantığı ve Davranışlar: Bir nesnenin sadece veri depolamakla kalmayıp, aynı zamanda önemli iş mantığını veya eylemleri de içermesi gerekiyorsa. Örneğin, bir OrderProcessor veya InventoryManager sınıfı.
• Kalıtım ve Polimorfizm: Bir nesne hiyerarşisi oluşturmanız veya farklı türevleri aynı temel tür üzerinden işlemeniz gerekiyorsa. Örneğin, farklı ödeme yöntemlerini (CreditCardPayment, PayPalPayment) ortak bir Payment sınıfı üzerinden yönetmek.
• Büyük Veri Yapıları: Eğer nesneniz çok sayıda alan içeriyorsa ve bellekte büyük bir yer kaplıyorsa, class kullanmak kopyalama maliyetini azaltır.
• Nesnelerin Referans ile Paylaşılması: Uygulamanın farklı bölümlerinin aynı nesne örneği üzerinde çalışması ve birbirlerinin değişikliklerini görmesi gerekiyorsa. Örneğin, bir kullanıcının oturum bilgilerini tutan tek bir Session nesnesi.

Ne Zaman Struct Kullanmalıyız?

struct'lar performans avantajları sunsa da, dikkatli kullanılmalıdır. Genellikle aşağıdaki durumlarda en verimli olurlar:

• Küçük ve Basit Veri Grupları: İki veya üç basit veri alanını (int, float, bool gibi) bir araya getiren yapılar için. Örneğin, Point (x, y), Color (R, G, B, A) veya DateTimeOffset gibi.
• Değişmezlik: Eğer struct'ın tüm özellikleri readonly ise, değişmez bir değer tipi elde edersiniz. Bu, multi-threading ortamlarında veya bir değerin değişmediğinden emin olmak istediğinizde güvenliği artırır.
• Performans Kritik Senaryolar: Oyun motorları, grafik uygulamaları gibi sıkça küçük nesnelerin oluşturulduğu ve kopyalandığı yerlerde, çöp toplama yükünü azaltmak için kullanılabilirler. Ancak, bu durumda struct'ın boyutu küçük kalmalıdır (tercihen 16 byte altında).
• Değer Semantiği: Bir nesnenin referansından ziyade, doğrudan kopyalanan "değerini" istediğinizde.

Ne Zaman Record Kullanmalıyız?

record'lar, modern C# uygulamalarında giderek daha fazla yer bulmaktadır. Özellikle aşağıdaki senaryolarda parlarlar:

• Veri Taşıma Nesneleri (DTO'lar): REST API'lerinden gelen veya gönderilen verileri modellemek için idealdirler. Değer tabanlı eşitlik sayesinde, veri setlerinin karşılaştırılması ve değişmezlik sayesinde güvenli aktarım kolaylaşır.
• Yapılandırma ve Ayar Nesneleri: Uygulama ayarları, konfigürasyon parametreleri gibi, bir kez yüklendikten sonra genellikle değişmeyen ve değerleri ile karşılaştırılması önemli olan veriler için uygundur.
• Değişmez Veri Modelleri: Fonksiyonel programlama prensiplerini benimseyen veya veri tutarlılığının kritik olduğu uygulamalarda, bir nesnenin durumunun asla doğrudan değiştirilemeyeceğini garanti etmek için kullanılır. with ifadesi, değişmezlik prensibini korurken kolayca yeni varyantlar oluşturmanızı sağlar.
• Değer Objeleri: Bir kimliği olmayan, sadece bir değer kümesini temsil eden nesneler için (örneğin, bir para birimi değeri CurrencyAmount(decimal amount, string code)).

Mobil Uyumlu C# Kod Yazımında Nelere Dikkat Edilmeli?

Mobil uygulamalar veya mobil cihazlara hizmet veren arka uç sistemleri geliştirirken, bellek kullanımı ve performans, masaüstü uygulamalarından çok daha kritik hale gelir. C#’taki record, class ve struct seçimleri, mobil ortamlardaki uygulamanızın enerji tüketimini, yanıt verme hızını ve genel kullanıcı deneyimini doğrudan etkileyebilir.

Performansın Mobil Cihazlarda Önemi

Mobil cihazlar genellikle daha kısıtlı işlem gücüne ve batarya ömrüne sahiptir. Bu nedenle, her bellek tahsisi (heap üzerinde class veya record class kullanıldığında), her çöp toplama işlemi ve her veri kopyalama (büyük struct'larda) uygulamanızın performansını olumsuz etkileyebilir. Özellikle:

• Bellek Ayak İzi: Daha az heap tahsisi, çöp toplayıcının daha az çalışması anlamına gelir. Bu da CPU döngülerinden tasarruf sağlar ve uygulamanın daha akıcı çalışmasına yardımcı olur. Küçük struct'lar bu konuda avantajlı olabilir.
• Veri Aktarımı: Mobil uygulamalar genellikle bir arka uç API'si ile etkileşime girer. Bu API'lardan gelen verileri modellemek için record'lar (özellikle record class) idealdir. Değişmezlikleri sayesinde, alınan verinin beklenmedik şekilde değiştirilmediğinden emin olabilir ve değer tabanlı eşitlik sayesinde verileri kolayca karşılaştırabilirsiniz. Bu, veri tutarlılığı ve hata ayıklama kolaylığı açısından mobil uygulamalarda büyük bir artıdır.
• Kopyalama Maliyetleri: Eğer çok sayıda küçük veri yapısı ile sıkça işlem yapılıyorsa (örneğin, oyun veya grafik uygulamalarında Vector2D gibi), struct kullanmak, heap tahsisini azaltarak performans artışı sağlayabilir. Ancak, büyük struct'lardan kaçınmak esastır, çünkü kopyalama maliyeti referans kopyalamadan daha yüksek hale gelebilir.

Örnek bir senaryoda, bir mobil uygulamanın API'den ürün listesini çektiğini düşünelim. Her bir ürünün, yalnızca görüntülenmek üzere kısa ömürlü bir nesne olarak kullanıldığı durumlarda, record kullanımı idealdir. Çünkü değişmezdirler, değer tabanlı eşitlik sağlarlar ve genellikle basit DTO'lar için optimize edilmiş bir sözdizimi sunarlar.

    // Mobil uygulama için API'dan gelen ürün verilerini temsil eden Record
    public record MobileProductDTO(int Id, string Name, decimal Price, string ImageUrl);

    // Bir API çağrısı sonucu elde edilen veri
    var productData = new MobileProductDTO(1, "Akıllı Telefon", 7500M, "http://example.com/phone.jpg");

    // Mobil uygulamada kullanılacak basit bir konum struct'ı
    // Sıkça oluşturulup kopyalanacağından struct burada avantajlı olabilir
    public readonly struct ScreenPosition
    {
        public int X { get; }
        public int Y { get; }

        public ScreenPosition(int x, int y) => (X, Y) = (x, y);
    }

    var touchPos = new ScreenPosition(150, 200);
    

Mobil uyumlu HTML üretme konusunda, C# kodunun doğrudan HTML ile ilişkisi olmasa da, bir C# geliştiricisi olarak web arayüzleri geliştirirken responsive design prensiplerini bilmek önemlidir. Yukarıdaki CSS örneği, web sitelerinin farklı ekran boyutlarına nasıl uyum sağlayabileceğini göstermektedir. C# ile backend geliştirirken de, mobil uygulamaların ihtiyaç duyduğu optimize edilmiş ve hafif JSON/XML yanıtları döndürmek, record'ları kullanarak veri modellerini sadeleştirmek gibi yaklaşımlar önemlidir.

Sonuç: C# Veri Modellerinde Ustalık

C# dilinde record, class ve struct, veri modelleme için geliştiricilere güçlü ve esnek seçenekler sunar. Her birinin kendine özgü tasarımı ve davranışsal özellikleri vardır, bu da onları farklı kullanım senaryoları için uygun hale getirir. Bu makale boyunca, bu üç yapının temel farklarını, ne zaman hangi yapıyı tercih etmeniz gerektiğini ve gerçek dünya senaryolarındaki uygulamalarını detaylıca inceledik. Özellikle, class'ların referans tabanlı karmaşık nesneler için, struct'ların küçük ve performans kritik değer tipleri için ve record'ların ise değişmez veri taşıma nesneleri ve değer odaklı modeller için ideal olduğunu vurguladık.

Anahtar çıkarım şudur: Tek bir "en iyi" seçenek yoktur. Karar, modellemek istediğiniz verinin doğasına, uygulamanızın performans beklentilerine, bellek kullanımına ve kodun sürdürülebilirliğine bağlıdır. Doğru seçimi yapmak, yalnızca kodunuzun daha verimli çalışmasını sağlamakla kalmaz, aynı zamanda daha okunabilir, bakımı kolay ve hataya daha az yatkın bir uygulama geliştirmenize de yardımcı olur. Bu derinlemesine bilgi birikimiyle, C# projelerinizde veri modellerinizi daha bilinçli ve stratejik bir şekilde tasarlayabilirsiniz.

Sıkça Sorulan Sorular

1. Struct'lar neden null olamaz?

struct'lar değer tipleri olduğu için, doğrudan bir değer tutarlar ve bellekte bir varlık olarak her zaman mevcutlardır. Bir struct örneği oluşturduğunuzda, tüm alanları varsayılan değerleriyle başlatılır. null, bir referansın hiçbir nesneyi işaret etmediği durumu ifade eder. struct'lar referans olmadığı için null olamazlar. Ancak, Nullable (örneğin int? veya MyStruct?) kullanarak bir struct'ı null yapılabilir hale getirebilirsiniz.

    struct MyStruct { public int Value; }
    MyStruct s1 = new MyStruct(); // Value = 0
    // MyStruct s2 = null; // Hata verir
    MyStruct? s3 = null; // Geçerli
    

2. Record'lar Class gibi metot içerebilir mi?

Evet, record'lar (record class ve record struct fark etmeksizin) aynen class'lar ve struct'lar gibi metotlar, özellikler, constructor'lar, interface uygulamaları ve hatta alanlar içerebilirler. Temel fark, record'ların değer tabanlı eşitlik, ToString() metodu override'ı ve with ifadesi gibi bazı üye metotları ve operatörleri otomatik olarak sağlamasıdır. Bu otomatik implementasyonlar, veri odaklı tipler için yaşam kalitesini artırır.

3. Büyük Struct'lar kullanmak neden kötü bir fikir olabilir?

Büyük struct'lar, temel olarak kopyalama maliyeti nedeniyle performans sorunlarına yol açabilir. Bir struct kopyalandığında (bir değişkene atandığında, bir metoda parametre olarak geçtiğinde veya bir metoddan döndüğünde), tüm verinin kendisi kopyalanır. Eğer struct büyükse (örneğin, birden fazla referans tipine veya çok sayıda alana sahipse), bu kopyalama işlemi önemli CPU ve bellek bant genişliği tüketebilir. Ayrıca, büyük struct'lar bazen heap'te de tutulmak zorunda kalabilir (boxing), bu da çöp toplama yükünü artırır. Genellikle, 16 byte'tan büyük struct'lar için class veya record class kullanmak daha iyi bir tercih olabilir.

4. Referans tipler ve değer tipleri arasındaki temel fark nedir?

En temel fark, bellekte nasıl davrandıklarıdır. Değer tipleri (struct, int, bool vb.), verinin kendisini doğrudan depolarlar. Bir değer tipi değişkene atandığında veya bir fonksiyona geçirildiğinde, verinin bir kopyası oluşturulur. Referans tipleri (class, record class, string, diziler vb.), verinin kendisini değil, verinin bellekte (heap) nerede saklandığına dair bir referansı (adresi) depolarlar. Bir referans tipi değişkene atandığında veya bir fonksiyona geçirildiğinde, yalnızca bu referans kopyalanır; orijinal veri aynı kalır. Bu durum, referans tiplerinin null olabilmesini de sağlar.

5. C# 10 ile gelen record struct ne işe yarar?

C# 10 ile tanıtılan record struct, record'ların sunduğu değer tabanlı eşitlik, with ifadesi gibi özelliklerini bir struct'ın değer tipi davranışıyla birleştirir. Bu, geliştiricilere değişmez, değer tabanlı eşitliğe sahip ancak heap tahsisinden kaçınan küçük veri yapıları oluşturma olanağı sunar. Genellikle, performans kritik senaryolarda küçük, değişmez değer tipleri için record struct ideal bir seçimdir, çünkü hem struct'ın bellek avantajlarını hem de record'ın kod okunabilirliği ve güvenliğini bir araya getirir. Özellikle DTO'ların bellek ayak izini minimize etmek istendiğinde kullanılabilir.