C# Record Tipleri ve MongoDB Kullanımı: Modern Veri Modelleme Yaklaşımları

C# Record Tipleri ve MongoDB Kullanımı: Modern Veri Modelleme Yaklaşımları

C# 9.0 ile hayatımıza giren record tipleri, özellikle veri taşıma nesneleri (DTO’lar) ve değişmez (immutable) veri yapıları oluşturma konusunda geliştiricilere yepyeni bir bakış açısı sunmuştur. Bu makalede, C# record tiplerinin MongoDB gibi esnek şemalı NoSQL veritabanlarıyla nasıl entegre edilebileceğini, sağladığı avantajları, karşılaşılabilecek zorlukları ve en iyi uygulama yöntemlerini detaylı bir şekilde inceleyeceğiz. Geleneksel sınıflara kıyasla record tiplerinin getirdiği yenilikler sayesinde, MongoDB ile daha temiz, güvenli ve sürdürülebilir veri modelleri oluşturmak mümkün hale gelmektedir.

C# Record Tiplerine Genel Bakış

C# record tipleri, .NET ekosisteminde veri odaklı sınıflar veya yapılar tanımlamak için tasarlanmış özel bir referans veya değer tipidir. Temel amacı, değişmez veri modelleri oluşturmayı basitleştirmek ve değer tabanlı eşitlik gibi özellikleri otomatik olarak sağlamaktır.

Record Tipleri Nedir?

record tipleri, genellikle veri kapsülleme amacıyla kullanılan, birincil yapıcı (primary constructor) aracılığıyla özelliklerini tanımlayabildiğimiz özel bir sınıf veya yapı türüdür. En belirgin özellikleri şunlardır:

* Değişmezlik (Immutability): Varsayılan olarak, record tiplerinin özellikleri init erişimcisi ile tanımlanır. Bu, nesne oluşturulduktan sonra özelliklerinin değiştirilemeyeceği anlamına gelir. Bu durum, özellikle çoklu iş parçacıklı (multi-threaded) ortamlarda veri tutarlılığını artırır.
* Değer Tabanlı Eşitlik: Geleneksel sınıflar referans tabanlı eşitlik kullanırken, record tipleri varsayılan olarak değer tabanlı eşitlik uygular. Yani, iki record nesnesi aynı özellik değerlerine sahipse, bunlar eşit kabul edilir.
* Kısa Söz Dizimi: record tipleri, özellikle birincil yapıcıları sayesinde çok daha az kodla tanımlanabilir. Bu, DTO’lar için boilerplate kodunu önemli ölçüde azaltır.
* with İfadesi: Değişmez olmalarına rağmen, record tipleri with ifadesi kullanılarak mevcut bir nesneden yola çıkarak yeni bir nesne oluşturmayı ve belirli özelliklerini değiştirmeyi kolaylaştırır.

Neden Record Tipleri Kullanmalıyız?

record tiplerinin kullanımı, yazılım geliştirme sürecine birçok avantaj sağlar:

• Kod Kısalığı ve Okunabilirlik: Daha az kodla daha fazla iş yaparak kod tabanını sadeleştirir.
• Hata Azaltma: Değişmezlik sayesinde, bir record nesnesinin durumu oluşturulduktan sonra değişmeyeceği için beklenmedik yan etkiler (side effects) azalır. Bu, özellikle karmaşık sistemlerde hata ayıklamayı kolaylaştırır.
• Güvenlik: Değişmez veri yapıları, çoklu iş parçacıklı uygulamalarda veri yarışlarını (data races) ve kilitlenmeleri (deadlocks) önlemeye yardımcı olur.
• Tutarlılık: Değer tabanlı eşitlik, veri karşılaştırmalarını daha sezgisel hale getirir.

Record Tiplerinin Söz Dizimi

Basit bir record tanımı şu şekildedir:

public record Product(string Id, string Name, decimal Price);

// Kullanım örneği
var product1 = new Product("P001", "Laptop", 1200.00m);
var product2 = new Product("P001", "Laptop", 1200.00m);

Console.WriteLine(product1 == product2); // Çıktı: True (değer tabanlı eşitlik)

var updatedProduct = product1 with { Price = 1250.00m };
Console.WriteLine(updatedProduct); // Çıktı: Product { Id = P001, Name = Laptop, Price = 1250.00 }

MongoDB ve NoSQL Veri Modellemesi

MongoDB, esnek, ölçeklenebilir ve yüksek performanslı bir NoSQL belge tabanlı veritabanıdır. Geleneksel ilişkisel veritabanlarının aksine, MongoDB şemasız bir yapıya sahiptir ve verileri JSON benzeri BSON (Binary JSON) formatında depolar.

MongoDB'ye Kısa Bir Giriş

MongoDB'nin temel özellikleri:

* Belge Tabanlı: Veriler, JSON benzeri belgeler (documents) halinde depolanır. Bu belgeler, anahtar-değer çiftlerinden oluşan dinamik şemalara sahiptir.
* Şemasız (Schema-less): Bir koleksiyondaki belgeler farklı alanlara sahip olabilir. Bu, hızlı prototipleme ve uygulama gereksinimleri değiştikçe kolayca adapte olabilme yeteneği sağlar.
* Yüksek Performans ve Ölçeklenebilirlik: Yatay ölçeklenebilirlik (sharding) ve yerleşik çoğaltma (replication) özellikleri sayesinde yüksek erişilebilirlik ve performans sunar.

Geleneksel C# Sınıfları ile MongoDB

MongoDB ile çalışırken, C# uygulamalarında genellikle geleneksel sınıflar (class) kullanılır. Bu sınıflar, veritabanındaki belgelerin birer temsilcisi olarak işlev görür.

public class OldProduct
{
    public string Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public DateTime CreatedAt { get; set; }
}

Bu yaklaşım çalışsa da, set erişimcileri nedeniyle nesneler değiştirilebilir (mutable) olduğundan, özellikle karmaşık iş mantığı ve eşzamanlı işlemler içeren uygulamalarda veri tutarlılığı sorunlarına yol açabilir. Ayrıca, manuel olarak Equals ve GetHashCode metotlarını geçersiz kılmak gerekebilir.

Esnek Şema ve Veri Tutarlılığı

MongoDB'nin esnek şeması, C# record tiplerinin değişmez yapısıyla harika bir uyum sağlayabilir. Bir record nesnesi oluşturulduktan sonra değiştirilemez olduğu için, veritabanına kaydedilen bir belgenin uygulama katmanında yanlışlıkla değiştirilme riski ortadan kalkar. Bu, özellikle kritik verilerle çalışırken veya denetlenebilir bir veri akışı sağlamak istendiğinde büyük bir avantajdır.

C# Record Tiplerini MongoDB ile Kullanmanın Temelleri

C# record tiplerini MongoDB ile kullanmak oldukça basittir, çünkü MongoDB C# sürücüsü record tiplerini geleneksel sınıflar gibi otomatik olarak serileştirip serileştirebilir.

Record Tipleriyle Belge Modelleme

Bir MongoDB belgesini bir record tipiyle modellemek, geleneksel sınıflarla modellemekten farksızdır. Tek fark, record tiplerinin sağladığı söz dizimi ve değişmezlik özellikleridir.

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

public record Order(
    [BsonId] ObjectId Id,
    [BsonElement("customerId")] string CustomerId,
    [BsonElement("orderDate")] DateTime OrderDate,
    [BsonElement("totalAmount")] decimal TotalAmount,
    [BsonElement("items")] List Items
);

public record OrderItem(
    [BsonElement("productId")] string ProductId,
    [BsonElement("productName")] string ProductName,
    [BsonElement("quantity")] int Quantity,
    [BsonElement("unitPrice")] decimal UnitPrice
);

Yukarıdaki örnekte, Order ve OrderItem record tipleri MongoDB belgelerini temsil etmek için kullanılmıştır. BsonId ve BsonElement gibi MongoDB.Bson.Serialization.Attributes nitelikleri, alanların MongoDB'deki karşılık gelen belge alan adlarıyla eşleşmesini sağlar.

MongoDB C# Sürücüsü ve Record Tipleri

MongoDB C# sürücüsü, record tiplerini varsayılan olarak destekler. Sürücü, record tiplerinin birincil yapıcılarını ve init erişimcilerini doğru bir şekilde anlar ve serileştirme/deserileştirme işlemlerini sorunsuz bir şekilde gerçekleştirir. Bu, geliştiricilerin ek bir yapılandırma yapmasına gerek kalmadan record tiplerini kullanabileceği anlamına gelir.

Örnek Bir Uygulama Yapısı

Basit bir CRUD (Create, Read, Update, Delete) uygulaması için record tipleriyle bir model tanımlayalım:

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

// Model tanımı
public record User(
    [BsonId] ObjectId Id,
    [BsonElement("username")] string Username,
    [BsonElement("email")] string Email,
    [BsonElement("registrationDate")] DateTime RegistrationDate
);

// Repository arayüzü
public interface IUserRepository
{
    Task GetByIdAsync(ObjectId id);
    Task> GetAllAsync();
    Task AddAsync(User user);
    Task UpdateAsync(User user); // Record'lar immutable olduğu için bu update işlemi yeni bir record oluşturup eskisinin yerine geçer.
    Task DeleteAsync(ObjectId id);
}

İleri Seviye Record ve MongoDB Entegrasyonu

record tiplerinin değişmez yapısı, MongoDB ile çalışırken bazı özel durumları ele almayı gerektirebilir, özellikle güncelleme işlemleri ve iç içe belgelerle ilgili olarak.

Immutability ve Güncelleme İşlemleri

record tipleri değişmez olduğundan, bir record nesnesinin bir özelliğini doğrudan değiştiremezsiniz. Bunun yerine, with ifadesini kullanarak mevcut bir record nesnesinden yeni bir record nesnesi oluşturursunuz.

MongoDB'de bir belgeyi güncellemek istediğinizde, genellikle belgenin tümünü almak, gerekli değişiklikleri yapmak ve ardından güncellenmiş belgeyi veritabanına geri yazmak istersiniz. record tipleriyle bu süreç şöyle işler:

public async Task UpdateUserEmailAsync(ObjectId userId, string newEmail)
{
    var existingUser = await _usersCollection.Find(u => u.Id == userId).FirstOrDefaultAsync();
    if (existingUser is null)
    {
        // Hata yönetimi
        return;
    }

    // Yeni bir record nesnesi oluştur
    var updatedUser = existingUser with { Email = newEmail };

    // MongoDB'de belgeyi güncelle
    await _usersCollection.ReplaceOneAsync(u => u.Id == userId, updatedUser);
}

Bu yaklaşım, veri tutarlılığını artırır çünkü her güncelleme işlemi yeni bir nesne yaratır ve eski nesnenin durumunu korur.

Nested Record Tipleri ve İlişkiler

MongoDB, iç içe belgeleri (nested documents) doğal olarak destekler. C# record tipleri de bu yapıyı kolayca modelleyebilir.

public record Address(
    [BsonElement("street")] string Street,
    [BsonElement("city")] string City,
    [BsonElement("zipCode")] string ZipCode
);

public record Customer(
    [BsonId] ObjectId Id,
    [BsonElement("name")] string Name,
    [BsonElement("email")] string Email,
    [BsonElement("address")] Address ShippingAddress // İç içe record
);

Bu yapı, Customer belgesinin ShippingAddress alanında bir Address record nesnesi içermesini sağlar. MongoDB sürücüsü, bu iç içe record yapılarını otomatik olarak serileştirip serileştirebilir.

Custom Serileştirme

Bazı durumlarda, MongoDB'ye özel serileştirme davranışları tanımlamak isteyebilirsiniz. record tipleri, geleneksel sınıflar gibi BsonIgnore, BsonElement, BsonRepresentation gibi MongoDB.Bson.Serialization.Attributes niteliklerini destekler.

* [BsonIgnore]: Bir özelliğin MongoDB'ye kaydedilmesini engeller.
* [BsonElement("fieldName")]: Özelliğin MongoDB'deki belge alan adını belirtir.
* [BsonRepresentation(BsonType.String)]: Özelliğin BSON'da nasıl temsil edileceğini belirtir (örn. enum değerlerini string olarak kaydetme).

public record SensorReading(
    [BsonId] ObjectId Id,
    [BsonElement("timestamp")] DateTime Timestamp,
    [BsonElement("value")] double Value,
    [BsonIgnoreIfDefault] string Unit = "Celcius" // Varsayılan değerse MongoDB'ye kaydetme
);

Record Tipleriyle Veri Doğrulama

Değişmez record tiplerinde veri doğrulama genellikle iki şekilde yapılabilir:

1. Yapıcı İçinde Doğrulama: record'ın birincil yapıcısında veya özel bir yapıcıda doğrulama mantığı ekleyebilirsiniz. Bu, geçersiz bir record nesnesinin asla oluşturulmamasını sağlar.

    public record ValidatedProduct(string Id, string Name, decimal Price)
    {
        public ValidatedProduct(string id, string name, decimal price) : this(id, name, price)
        {
            if (string.IsNullOrWhiteSpace(id)) throw new ArgumentException("Id cannot be empty.");
            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Name cannot be empty.");
            if (price <= 0) throw new ArgumentOutOfRangeException(nameof(price), "Price must be positive.");
        }
    }
    

2. Harici Doğrulama: record nesnesi oluşturulduktan sonra, harici bir doğrulama servisi veya metodu kullanarak doğrulama yapabilirsiniz. Bu, özellikle karmaşık iş kuralları için daha esnek olabilir.

Performans ve En İyi Uygulamalar

record tiplerini MongoDB ile kullanırken performans ve en iyi uygulamalar hakkında bazı önemli noktalar bulunmaktadır.

Bellek Kullanımı ve Performans İpuçları

record tipleri, referans tipleri (class record) veya değer tipleri (struct record) olarak tanımlanabilir. Varsayılan olarak, record bir referans tipidir ve yığın (heap) üzerinde depolanır.

* Referans Tipli Record'lar: Büyük record nesneleri için performans etkisi geleneksel sınıflara benzerdir. Bellek tahsis maliyeti vardır.
* Değer Tipli Record'lar (record struct): Küçük ve sık kullanılan veri yapıları için record struct kullanmak, yığın tahsisini azaltarak performans avantajı sağlayabilir. Ancak, büyük record struct'lar kopyalama maliyeti nedeniyle performans düşüşüne neden olabilir.

Genel olarak, record tiplerinin performans maliyeti, sundukları kod kalitesi ve güvenilirlik avantajlarına kıyasla genellikle kabul edilebilir düzeydedir.

Veri Tutarlılığı ve Hata Yönetimi

record tiplerinin değişmezliği, veri tutarlılığını doğal olarak artırır. Bir record nesnesi oluşturulduktan sonra durumu değişmediği için, aynı nesne üzerinde eşzamanlı değişiklikler yapma riski ortadan kalkar. Bu, özellikle dağıtık sistemlerde ve mikroservis mimarilerinde hata yönetimini basitleştirir. Hatalar genellikle nesne oluşturma anında yakalanır ve geçersiz durumlar oluşması engellenir.

Sürüm Kontrolü ve Şema Değişiklikleri

MongoDB'nin esnek şeması ve record tiplerinin değişmezliği, şema evrimini yönetmeyi kolaylaştırabilir. Yeni alanlar eklediğinizde veya mevcut alanları değiştirdiğinizde:

* Yeni Alan Ekleme: record tanımınıza yeni bir özellik ekleyebilirsiniz. Eski belgeler bu alana sahip olmayacak, ancak MongoDB C# sürücüsü varsayılan değerlerle veya null ile sorunsuz bir şekilde serileştirecektir.
* Mevcut Alanları Değiştirme: Bir alanın adını veya tipini değiştiriyorsanız, BsonElement niteliğini kullanarak eski alan adını koruyabilir veya veritabanında bir veri geçişi (migration) yapmanız gerekebilir. record'ların değişmezliği, bu geçişler sırasında veri bütünlüğünü korumayı kolaylaştırır.

Pratik Kod Örnekleri

Şimdiye kadar öğrendiklerimizi pekiştirmek için pratik kod örneklerine göz atalım.

Basit Bir Record Modeli Tanımlama

Bir blog gönderisi için record modeli:

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

public record BlogPost(
    [BsonId] ObjectId Id,
    [BsonElement("title")] string Title,
    [BsonElement("content")] string Content,
    [BsonElement("author")] string Author,
    [BsonElement("publishDate")] DateTime PublishDate,
    [BsonElement("tags")] List Tags
);

MongoDB'ye Belge Ekleme

Yukarıdaki BlogPost modelini kullanarak MongoDB'ye yeni bir belge ekleyelim:

using MongoDB.Driver;

public class BlogService
{
    private readonly IMongoCollection _blogPosts;

    public BlogService(IMongoClient client)
    {
        var database = client.GetDatabase("BlogDb");
        _blogPosts = database.GetCollection("posts");
    }

    public async Task CreatePostAsync(string title, string content, string author, List tags)
    {
        var newPost = new BlogPost(
            Id: ObjectId.GenerateNewId(),
            Title: title,
            Content: content,
            Author: author,
            PublishDate: DateTime.UtcNow,
            Tags: tags
        );
        await _blogPosts.InsertOneAsync(newPost);
        Console.WriteLine($"New post created with ID: {newPost.Id}");
    }
}

Belge Sorgulama ve Güncelleme (Immutable Yaklaşım ile)

Bir blog gönderisini sorgulayalım ve with ifadesi kullanarak güncelleyelim:

public async Task UpdatePostTitleAsync(ObjectId postId, string newTitle)
{
    var existingPost = await _blogPosts.Find(p => p.Id == postId).FirstOrDefaultAsync();
    if (existingPost is null)
    {
        Console.WriteLine($"Post with ID {postId} not found.");
        return;
    }

    // Yeni bir record nesnesi oluşturarak başlığı güncelle
    var updatedPost = existingPost with { Title = newTitle };

    // MongoDB'de belgeyi değiştir
    var result = await _blogPosts.ReplaceOneAsync(p => p.Id == postId, updatedPost);

    if (result.IsAcknowledged && result.ModifiedCount > 0)
    {
        Console.WriteLine($"Post {postId} title updated to '{newTitle}'.");
    }
    else
    {
        Console.WriteLine($"Failed to update post {postId}.");
    }
}

public async Task GetPostByIdAsync(ObjectId postId)
{
    return await _blogPosts.Find(p => p.Id == postId).FirstOrDefaultAsync();
}

Kompleks Bir Record Yapısı

İç içe record tipleri ve koleksiyonlar içeren daha karmaşık bir yapı:

public record Comment(
    [BsonElement("commenter")] string Commenter,
    [BsonElement("text")] string Text,
    [BsonElement("commentDate")] DateTime CommentDate
);

public record Article(
    [BsonId] ObjectId Id,
    [BsonElement("headline")] string Headline,
    [BsonElement("body")] string Body,
    [BsonElement("authorId")] ObjectId AuthorId,
    [BsonElement("publicationDate")] DateTime PublicationDate,
    [BsonElement("categories")] List Categories,
    [BsonElement("comments")] List Comments // İç içe record listesi
);

Sonuç

C# record tipleri, MongoDB ile çalışan .NET geliştiricileri için modern ve etkili bir veri modelleme aracı sunmaktadır. Değişmezlik, değer tabanlı eşitlik ve kısa söz dizimi gibi özellikleri sayesinde, daha güvenli, okunabilir ve sürdürülebilir uygulamalar geliştirmek mümkündür. MongoDB'nin esnek şemasıyla record tiplerinin değişmez yapısının birleşimi, veri tutarlılığını artırırken aynı zamanda hızlı adaptasyon ve geliştirme süreçlerine olanak tanır. Uygulamalarınızda veri taşıma nesneleri veya değişmez veri modelleri gerektiren her yerde record tiplerini kullanmayı düşünmek, kod kalitenizi önemli ölçüde artıracaktır.

SSS (Sık Sorulan Sorular)

Record tipleri performans açısından geleneksel sınıflardan farklı mı?

record tipleri (class record) genellikle yığın (heap) üzerinde depolandıkları için bellek tahsisi ve çöp toplama (garbage collection) maliyetleri geleneksel sınıflara benzerdir. Ancak, değer tabanlı eşitlik gibi otomatik olarak uygulanan metotlar, manuel implementasyona göre bazen daha hızlı veya daha yavaş olabilir. Küçük veri yapıları için record struct kullanmak, yığın tahsisini azaltarak performans avantajı sağlayabilir. Genel olarak, record tiplerinin performans farkı çoğu uygulama için ihmal edilebilir düzeydedir.

MongoDB'de Record tipleriyle karmaşık ilişkiler nasıl yönetilir?

MongoDB, ilişkisel veritabanları gibi doğrudan ilişki tanımları sunmaz. record tipleriyle karmaşık ilişkiler, iç içe record'lar (embedded documents) veya referanslar (document references) kullanılarak yönetilir. İç içe record'lar, ilişkili verinin ana belge içinde depolanması anlamına gelirken, referanslar bir belgeden diğerine ObjectId ile referans verilmesidir. record tiplerinin değişmezliği, bu yaklaşımları uygularken veri tutarlılığını sağlamaya yardımcı olur.

Mevcut bir projede Record tiplerine geçiş yapmalı mıyım?

Mevcut bir projede record tiplerine geçiş yapmak, özellikle DTO'lar ve değişmez veri modelleri için kod kalitesini artırabilir. Ancak, bu bir refactoring çabası gerektirir. Eğer projeniz zaten kararlı ve değiştirilebilir sınıflar üzerinde yoğun bir bağımlılığa sahipse, geçişin faydalarını ve maliyetlerini dikkatlice değerlendirmelisiniz. Yeni modüller veya DTO'lar için record tiplerini kullanmaya başlamak iyi bir başlangıç noktası olabilir.

Record tipleri null değerleri nasıl ele alır?

C# 8.0 ile tanıtılan Nullable Reference Types (NRTs) özelliği, record tipleriyle de uyumludur. record özelliklerini string? gibi null atanabilir olarak tanımlayarak null değerleri açıkça belirtebilirsiniz. MongoDB C# sürücüsü, null atanabilir özellikleri veritabanına kaydederken veya okurken bu durumu doğru bir şekilde yönetir. Örneğin, bir alan null ise, MongoDB belgesinde o alan genellikle eksik olacaktır.