İçeriğe geç
Yazılım ve Teknoloji

C# extension method: doğru ve yanlış yazım yolları

Rıfat Akarca 👁️ 3 okunma 📅 ⏱️ 6 dk okuma
İçindekiler

Bir C# extension method yazmak beş dakikalık iştir. Sorun, yanlış yazılmış bir extension method'un aylarca fark edilmemesidir: null referans hatası yanlış satırı gösterir, EF Core sorgusu sessizce belleğe taşınır, bir instance metot extension'ınızı hiç çalıştırmaz.

Bu yazıda extension method'un derleyici düzeyinde nasıl çözüldüğünü, sık yapılan hataları ve doğru karşılıklarını görecek, ardından .NET 10 ile gelen C# 14 extension members söz diziminin klasik yöntemle farkına bakacaksınız.

Extension method aslında nedir?

Extension method, bir tipin kaynağına dokunmadan ona yeni bir metot eklemiş gibi görünmenizi sağlayan statik bir metottur. Klasik söz diziminde ilk parametre this anahtar sözcüğüyle işaretlenir ve metot statik bir sınıf içinde tanımlanır.

Burada hatırlanması gereken üç kural var:

  • Çağrı x.Metot() biçiminde yazılsa da derleyici bunu Sinif.Metot(x) çağrısına çevirir. Nesneye ait bir şey eklenmiş olmaz, özel üyelere erişilemez.
  • Çözümleme derleme zamanında yapılır. Çalışma zamanı tipine göre polimorfik davranış yoktur.
  • Aynı imzada bir instance metot varsa her zaman o kazanır. Extension hiç seçilmez ve derleyici uyarı vermez.

Üçüncü kural, aşağıdaki hataların çoğunun kökenidir.

Yanlış: Null kontrolü yapmamak

Extension method null bir referans üzerinde çağrılabilir, çünkü ortada gerçek bir instance çağrısı yoktur. NullReferenceException, çağıran satırda değil extension'ın içinde fırlar ve hata yanlış yeri işaret eder.

public static class StringExtensions
{
    public static string Truncate(this string value, int maxLength)
        => value.Length <= maxLength ? value : value[..maxLength];
}

Doğrusu, argümanları metodun girişinde doğrulamaktır. ArgumentNullException.ThrowIfNull parametre adını otomatik yakalar, hata mesajı doğrudan sorunlu argümanı gösterir.

public static class StringExtensions
{
    public static string Truncate(this string value, int maxLength)
    {
        ArgumentNullException.ThrowIfNull(value);
        ArgumentOutOfRangeException.ThrowIfNegative(maxLength);

        return value.Length <= maxLength ? value : value[..maxLength];
    }
}

Null kabul eden bir extension yazıyorsanız parametreyi string? olarak işaretleyin ki sözleşme imzadan okunsun. Bu konunun temelleri için nullable reference types yazısına bakabilirsiniz.

Iterator döndüren extension'larda doğrulama gecikir

yield return kullanan bir metodun gövdesi, sonuç ilk kez enumerate edilene kadar çalışmaz. Doğrulamayı aynı metoda koyarsanız hata, çağrı anında değil çok sonra ve çağrının yapıldığı yerden uzakta ortaya çıkar. Çözüm, doğrulamayı dış metotta yapıp iterator'ı yerel bir metoda ayırmaktır.

public static class EnumerableExtensions
{
    public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source)
        where T : class
    {
        ArgumentNullException.ThrowIfNull(source);
        return Iterator(source);

        static IEnumerable<T> Iterator(IEnumerable<T?> items)
        {
            foreach (var item in items)
            {
                if (item is not null)
                    yield return item;
            }
        }
    }
}

Bu davranışın arkasındaki mantığı LINQ deferred execution yazısında ayrıntılı bulabilirsiniz.

Yanlış: Her tipe uygulanan extension yazmak

this object ya da kısıtsız bir this T üzerine yazılan extension, projedeki her değişkenin IntelliSense listesini kirletir. Üstelik çoğu zaman gizli bir tasarım sorununa işaret eder.

public static class ObjectExtensions
{
    public static string ToJson<T>(this T value)
        => System.Text.Json.JsonSerializer.Serialize(value);
}

Doğrusu, extension'ı gerçekten ait olduğu en dar tipe bağlamaktır. Genel amaçlı bir yardımcıysa düz bir statik metot (JsonHelper.Serialize(x)) çoğu zaman daha dürüsttür. Şu soruyu sorun: "Bu metot, bu tipin doğal bir davranışı mı?"

Aynı mantık bağımlılıklar için de geçerlidir. Extension method durum tutamaz ve DI ile servis enjekte edemez. Bir veritabanı çağrısı, HTTP isteği ya da iş kuralı gerekiyorsa o iş bir serviste yaşamalıdır. Extension'a sürekli servis parametre olarak geçiriyorsanız yanlış yerdesinizdir.

Namespace de bir tasarım kararıdır. Uygulama kodunda extension'ları kendi özellik klasörünüzün namespace'inde tutun. System ya da Microsoft.Extensions.DependencyInjection gibi namespace'lere koymak, kütüphane yazarlarının keşfedilebilirlik için bilinçle yaptığı bir tercihtir. Uygulamada gereksiz bir sürprizdir.

Yanlış: Instance metodun extension'ı gölgelediğini unutmak

public class Order
{
    public decimal Total() => 100m;
}

public static class OrderExtensions
{
    public static decimal Total(this Order order) => 0m;
}

var total = new Order().Total();

total her zaman 100 olur. Extension derlenir, ama çağrılmaz.

Bu durum özellikle üçüncü parti ya da framework tiplerinde sinsidir. Bir kütüphane sonraki sürümde sizin extension'ınızla aynı imzada bir instance metot eklerse kodunuz sessizce o metoda geçer. Davranış değişir, derleme hatası gelmez.

Önlemler basit:

  • Sahibi olmadığınız tiplerde çok genel isimlerden (Contains, Add, Clear) kaçının.
  • Extension'ın davranışını birim testle kilitleyin. Gölgelenme olursa test kırılır.
  • Sahibi olduğunuz bir tip için extension yazıyorsanız metodu doğrudan tipe ekleyin.

Yanlış: IEnumerable ile IQueryable farkını gözetmemek

EF Core sorgularında yapılan en pahalı extension hatası budur. DbSet hem IQueryable<T> hem IEnumerable<T> uyguladığı için IEnumerable<T> alan bir extension rahatça çağrılabilir. Ancak içindeki Where artık Enumerable.Where'dır ve filtre veritabanında değil bellekte çalışır.

public record Customer(int Id, string Name, bool IsActive);

public static class CustomerQueryExtensions
{
    public static IEnumerable<Customer> Active(this IEnumerable<Customer> source)
        => source.Where(c => c.IsActive);
}

Doğrusu, sorgu kuran extension'ın IQueryable<T> üzerinde tanımlanmasıdır. Böylece lambda bir expression tree olarak kalır ve SQL'e çevrilebilir.

public static class CustomerQueryExtensions
{
    public static IQueryable<Customer> Active(this IQueryable<Customer> source)
        => source.Where(c => c.IsActive);

    public static IEnumerable<Customer> Active(this IEnumerable<Customer> source)
        => source.Where(c => c.IsActive);
}

İki overload birlikte durabilir. IQueryable alıcılı çağrılarda derleyici daha özel olan IQueryable sürümünü seçer. Aradaki farkı IEnumerable, ICollection, IList ve IQueryable karşılaştırmasında görebilirsiniz.

C# 14 ile extension members

C# 14 (.NET 10 SDK) extension bloklarını getirdi. Artık alıcı tipi bir blokta bir kez tanımlıyor, altına birden fazla üye yazıyorsunuz. Bu söz dizimi yalnızca metot değil, extension property ve statik extension üyeleri de mümkün kılıyor.

public static class StringExtensions
{
    extension(string value)
    {
        public bool IsBlank => string.IsNullOrWhiteSpace(value);

        public string Truncate(int maxLength)
        {
            ArgumentNullException.ThrowIfNull(value);
            ArgumentOutOfRangeException.ThrowIfNegative(maxLength);

            return value.Length <= maxLength ? value : value[..maxLength];
        }
    }
}

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        public bool IsEmpty => !source.Any();
    }
}

Kullanım "merhaba".IsBlank ya da items.IsEmpty şeklinde olur. Statik üye eklemek için alıcıya isim vermeden extension(Tip) yazılır ve bloğun içinde static üyeler tanımlanır.

Dikkat edilmesi gereken noktalar:

  • Klasik this söz dizimi geçerliliğini koruyor. Mevcut kodu zorunlu olarak taşımanız gerekmez, iki yöntem aynı sınıfta bir arada durabilir.
  • Extension'lar yine örnek durumu (instance state) tutamaz. Extension field diye bir şey yok, property'ler hesaplanan değerlerdir.
  • Yukarıdaki tüm kurallar (null kontrolü, gölgelenme, IQueryable) yeni söz dizimi için de geçerlidir.
  • Hedef framework ve SDK sürümü C# 14'ü desteklemiyorsa blok söz dizimi derlenmez. Kütüphane yazıyorsanız tüketicilerin sürümünü düşünün.

Dil sürümü konusunda genel bir bakış için C# 13 özellikleri yazısı iyi bir önceki halkadır.

Ne zaman extension method yazmalı?

DurumKarar
Sahibi olmadığınız tipe küçük, saf (pure) yardımcı davranışUygun
Fluent API ya da sorgu zinciri (IQueryable üzerinde yeniden kullanılabilir filtre)Uygun
Interface'e, implement eden herkesin ortak kullanacağı yardımcıUygun
Veritabanı, HTTP ya da servis bağımlılığı gereken işUygun değil, servis yazın
Sahibi olduğunuz tipin kendi davranışıUygun değil, tipe ekleyin
this object üzerine genel amaçlı yardımcıUygun değil

Bir extension method'u yayına almadan önce şu kısa listeye bakın: argüman doğrulaması var mı, adı instance metotlarla çakışıyor mu, doğru namespace'te mi, IQueryable ile kullanılma ihtimali var mı ve testi yazıldı mı?

Sık Sorulan Sorular

Extension method ile instance metot aynı isimde olursa hangisi çalışır?

Aynı imzada ise her zaman instance metot çalışır ve extension hiç çağrılmaz. Derleyici bu durumda uyarı da vermez. Parametre tipleri farklıysa normal overload çözümlemesi uygulanır.

Extension method içinde null kontrolü gerekli mi?

Evet. Extension method null bir alıcı üzerinde de çağrılabilir ve null kontrolü olmazsa hata extension'ın içinde, yanıltıcı bir yığın izinde fırlar. Parametrenin null olabileceğini kabul ediyorsanız bunu string? gibi nullable bir tipin imzasıyla belirtin.

Extension method içinde dependency injection kullanılabilir mi?

Doğrudan kullanılamaz, çünkü extension method statiktir ve constructor'ı yoktur. Bağımlılığı parametre olarak geçirebilirsiniz, ancak bu genellikle işin bir serviste yapılması gerektiğinin işaretidir. DI hakkında daha fazlası için .NET'te Dependency Injection yazısına göz atabilirsiniz.

C# 14 extension block'ları eski söz dizimini kaldırıyor mu?

Hayır. this parametreli klasik extension method'lar geçerli olmaya devam ediyor ve ikisi aynı projede birlikte kullanılabilir. Yeni söz dizimi özellikle extension property ve statik extension üyeleri için gerekli.

Sonuç

İyi bir C# extension method küçük, saf, doğru tipe bağlı ve argümanlarını girişte doğrulayan bir metottur. Instance metotların extension'ı gölgelediğini ve IEnumerable ile IQueryable arasındaki farkın performansı doğrudan etkilediğini aklınızda tutun. C# 14 extension block'ları söz dizimini genişletti ama bu kuralları değiştirmedi.