C# Reflection: Çalışma Zamanında Sınıf Özelliklerine Erişim

C# programlama dilinde, kodunuzu derledikten sonra bile programınızın yapısı hakkında bilgi edinmek ve bu yapıyı dinamik olarak değiştirmek mümkün müdür? Evet, bu yetenek “Reflection” (Yansıma) adı verilen güçlü bir mekanizma sayesinde sağlanır. Reflection, özellikle çalışma zamanında (runtime) tip bilgilerine, üyelere (metotlar, özellikler, alanlar vb.) ve hatta derleme zamanında bilinmeyen tiplere erişim ve manipülasyon imkanı sunar. Bu makalede, C# Reflection’ın temel prensiplerini, özellikle sınıf özelliklerine (properties) çalışma zamanında nasıl erişileceğini detaylı örneklerle inceleyeceğiz.

C# Reflection Nedir?

C# Reflection, .NET Framework ve .NET Core’un temel bir parçası olan ve çalışma zamanında meta verilere erişim sağlayan bir API setidir. Bir program çalışırken, Reflection sayesinde kodunuzun kendi yapısı hakkında bilgi edinebilirsiniz. Bu, bir sınıfın hangi metotlara, özelliklere veya alanlara sahip olduğunu, bunların erişim belirleyicilerini (public, private vb.) ve hatta değerlerini dinamik olarak okuyup değiştirebileceğiniz anlamına gelir. Reflection, özellikle esnek ve genişletilebilir uygulamalar geliştirmek isteyen yazılımcılar için vazgeçilmez bir araçtır.

Peki, Reflection ne işe yarar?

• Dinamik Kod Yürütme: Derleme zamanında bilinmeyen tiplerin metotlarını çağırabilir veya özelliklerine erişebilirsiniz.
• Meta Veri İncelemesi: Derlenmiş bir derlemenin (assembly) içindeki tipleri, metotları, özellikleri ve diğer üyeleri inceleyebilirsiniz.
• Uygulama Genişletilebilirliği: Plugin (eklenti) sistemleri, ORM (Object-Relational Mapping) araçları ve IoC (Inversion of Control) konteynerleri gibi gelişmiş mimarilerde temel bir rol oynar.
• Serileştirme/Deserileştirme: Nesneleri farklı formatlara (JSON, XML) dönüştürme veya geri yükleme işlemlerinde kullanılır.

Reflection API Temelleri: Type ve PropertyInfo

C# Reflection’ı kullanırken karşılaşacağınız en temel ve merkezi sınıf System.Type sınıfıdır. Bir nesnenin veya tipin meta verilerine erişmek için öncelikle o tipin bir Type nesnesine ihtiyacınız vardır.

Type Sınıfı ile Tip Bilgisi Edinme

Bir tipin Type nesnesini elde etmenin birkaç yolu vardır:

1. typeof operatörü ile (derleme zamanında bilinen tipler için):

   Type myClassType = typeof(MyClass);

2. GetType() metodu ile (bir nesnenin çalışma zamanı tipi için):

   MyClass myObject = new MyClass();
   Type myObjectType = myObject.GetType();

3. Type.GetType() statik metodu ile (tipin tam adını kullanarak):

   Type dynamicType = Type.GetType("MyNamespace.MyClass, MyAssembly");

Type nesnesini elde ettikten sonra, bu tip hakkında birçok bilgiye erişebilirsiniz. Örneğin, GetProperties() metodu ile tipin tüm özelliklerini (properties), GetMethods() ile metotlarını ve GetFields() ile alanlarını alabilirsiniz.

PropertyInfo Sınıfı ile Özellik Bilgisine Erişme

Bir tipin özelliklerine erişmek için Type sınıfının GetProperties() veya GetProperty(string name) metotlarını kullanırız. Bu metotlar, PropertyInfo sınıfının bir örneğini veya bir koleksiyonunu döndürür. PropertyInfo sınıfı, belirli bir özelliğin adı, tipi, erişim belirleyicileri gibi meta verilerini içerir ve en önemlisi, o özelliğin değerini okuma veya ayarlama yeteneği sunar.

PropertyInfo sınıfının anahtar metotları:

• GetValue(object obj): Belirtilen nesnenin üzerinde, bu PropertyInfo nesnesinin temsil ettiği özelliğin değerini alır.
• SetValue(object obj, object value): Belirtilen nesnenin üzerinde, bu PropertyInfo nesnesinin temsil ettiği özelliğin değerini ayarlar.

Bu metotlar, obj parametresi olarak özelliğin ait olduğu nesnenin bir örneğini bekler. Statik özellikler için obj parametresi null olabilir.

Çalışma Zamanında Sınıf Özelliklerine Erişim

Şimdi, Reflection kullanarak bir sınıfın özelliklerine nasıl erişeceğimize dair pratik örneklere geçelim. Örneklerimiz için basit bir Product sınıfı tanımlayalım:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    private string InternalCode { get; set; } // Private özellik

    public Product(int id, string name, decimal price, string internalCode)
    {
        Id = id;
        Name = name;
        Price = price;
        InternalCode = internalCode;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Product: Id={Id}, Name={Name}, Price={Price:C}");
    }
}

Örnek 1: Özellik Değerlerini Okuma

Bir Product nesnesinin özellik değerlerini Reflection ile nasıl okuyacağımızı görelim.

using System;
using System.Reflection;

public class Program
{
    public static void Main(string[] args)
    {
        Product laptop = new Product(101, "Gaming Laptop", 1500.00m, "GLAP-X7");

        // 1. Tip nesnesini al
        Type productType = laptop.GetType();

        // 2. Belirli bir özelliğe eriş
        PropertyInfo nameProperty = productType.GetProperty("Name");
        PropertyInfo priceProperty = productType.GetProperty("Price");

        if (nameProperty != null)
        {
            // 3. Özellik değerini oku
            string productName = (string)nameProperty.GetValue(laptop);
            Console.WriteLine($"Ürün Adı (Reflection ile): {productName}");
        }

        if (priceProperty != null)
        {
            decimal productPrice = (decimal)priceProperty.GetValue(laptop);
            Console.WriteLine($"Ürün Fiyatı (Reflection ile): {productPrice:C}");
        }

        // Not: GetProperty varsayılan olarak sadece public özellikleri getirir.
        // Private özelliklere erişmek için BindingFlags kullanmalıyız.
        PropertyInfo internalCodeProperty = productType.GetProperty("InternalCode", BindingFlags.Instance | BindingFlags.NonPublic);
        if (internalCodeProperty != null)
        {
            string internalCode = (string)internalCodeProperty.GetValue(laptop);
            Console.WriteLine($"Dahili Kod (Reflection ile): {internalCode}");
        }
        else
        {
            Console.WriteLine("Dahili Kod özelliğine erişilemedi (yanlış BindingFlags olabilir).");
        }
    }
}

Yukarıdaki örnekte, GetType() ile laptop nesnesinin Type objesini aldık. Ardından GetProperty("Name") ile “Name” özelliğine ait PropertyInfo objesini elde ettik. GetValue(laptop) metodu sayesinde, laptop nesnesinin “Name” özelliğinin güncel değerini okuduk. Önemli bir not: Özel (private) özelliklere erişmek için GetProperty metoduna BindingFlags.Instance | BindingFlags.NonPublic parametrelerini eklememiz gerekir.

Örnek 2: Özellik Değerlerini Ayarlama

Şimdi de Reflection kullanarak bir özelliğin değerini nasıl değiştireceğimizi görelim.

using System;
using System.Reflection;

public class Program
{
    public static void Main(string[] args)
    {
        Product tablet = new Product(202, "Android Tablet", 300.00m, "ATAB-S1");
        Console.WriteLine($"Başlangıç Fiyatı: {tablet.Price:C}");

        Type productType = tablet.GetType();
        PropertyInfo priceProperty = productType.GetProperty("Price");

        if (priceProperty != null && priceProperty.CanWrite) // CanWrite kontrolü önemli
        {
            // Yeni değeri ayarla
            priceProperty.SetValue(tablet, 350.50m);
            Console.WriteLine($"Yeni Fiyat (Reflection ile): {tablet.Price:C}");
        }
        else
        {
            Console.WriteLine("Fiyat özelliğine yazılamıyor veya bulunamadı.");
        }

        // Private özelliği ayarlama
        PropertyInfo internalCodeProperty = productType.GetProperty("InternalCode", BindingFlags.Instance | BindingFlags.NonPublic);
        if (internalCodeProperty != null && internalCodeProperty.CanWrite)
        {
            internalCodeProperty.SetValue(tablet, "ATAB-S1-UPDATED");
            // Değeri okuyarak doğrula
            string updatedInternalCode = (string)internalCodeProperty.GetValue(tablet);
            Console.WriteLine($"Güncellenmiş Dahili Kod: {updatedInternalCode}");
        }
    }
}

SetValue metodunu kullanarak tablet nesnesinin “Price” özelliğinin değerini değiştirdik. CanWrite özelliği, bir özelliğin yazılabilir olup olmadığını kontrol etmek için faydalıdır. Yalnızca get erişimcisi olan özellikler için CanWrite false dönecektir.

Tüm Özellikleri Listeleme

Bir tipin tüm public özelliklerini listelemek ve değerlerini yazdırmak da oldukça kolaydır.

using System;
using System.Reflection;

public class Program
{
    public static void Main(string[] args)
    {
        Product mouse = new Product(303, "Wireless Mouse", 25.99m, "WMOU-Z9");

        Type productType = mouse.GetType();

        Console.WriteLine($"--- '{productType.Name}' Sınıfının Özellikleri ---");

        // Tüm public özellikleri al
        PropertyInfo[] properties = productType.GetProperties(BindingFlags.Public | BindingFlags.Instance);

        foreach (PropertyInfo property in properties)
        {
            // Özelliğin adını ve değerini yazdır
            object value = property.GetValue(mouse);
            Console.WriteLine($"  {property.Name}: {value}");
        }

        // Tüm public ve private özellikleri almak için:
        Console.WriteLine($"\n--- '{productType.Name}' Sınıfının Tüm Özellikleri (Public/NonPublic) ---");
        PropertyInfo[] allProperties = productType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        foreach (PropertyInfo property in allProperties)
        {
            object value = property.GetValue(mouse);
            Console.WriteLine($"  {property.Name}: {value}");
        }
    }
}

GetProperties() metoduna farklı BindingFlags kombinasyonları vererek sadece public, sadece private veya hem public hem de private özellikleri listeleyebilirsiniz. BindingFlags.Instance, örnek (instance) özelliklerini kapsar; statik özellikler için BindingFlags.Static kullanılır.

Reflection Kullanım Alanları ve Dikkat Edilmesi Gerekenler

Reflection, C# geliştiricileri için son derece güçlü bir araçtır, ancak her güç gibi dikkatli kullanılmalıdır.

Yaygın Kullanım Alanları:

• ORM Kütüphaneleri (Entity Framework, Dapper): Veritabanı tablolarını C# sınıflarına eşlerken, sütun adlarını ve tiplerini dinamik olarak bulmak ve nesnelerin özelliklerini doldurmak için Reflection kullanılır.
• IoC Konteynerleri (Autofac, Unity): Bağımlılık enjeksiyonu yaparken, tipleri çözümlemek ve nesnelerin özelliklerine bağımlılıkları enjekte etmek için Reflection’dan faydalanılır.
• Serileştirme/Deserileştirme (JSON.NET, XML Serializer): Nesneleri metin tabanlı formatlara dönüştürürken veya bu formatlardan geri dönüştürürken, nesnelerin özelliklerini dinamik olarak tarar.
• Plugin ve Genişletilebilir Uygulama Mimarileri: Uygulamanıza harici derlemelerden yeni tipler yükleyerek, bu tiplerin metotlarını ve özelliklerini çalışma zamanında keşfedip kullanabilirsiniz.
• Test Otomasyonu: Özel veya korumalı üyelere erişim sağlayarak daha kapsamlı birim testleri yazmak mümkün olabilir (ancak genellikle kaçınılması önerilir).

Dikkat Edilmesi Gerekenler:

• Performans: Reflection, doğrudan tip erişimine göre önemli ölçüde daha yavaştır. Çünkü çalışma zamanında meta veri aramaları ve dinamik çağrılar içerir. Performans kritik uygulamalarda aşırı kullanmaktan kaçınılmalıdır.
• Güvenlik: Reflection, private üyelere erişim sağlayabildiği için güvenlik açıklarına yol açabilir. Güvenilmeyen kodun Reflection kullanmasını engellemek için güvenlik politikaları uygulanabilir.
• Bakım Zorluğu: Reflection kullanan kod, derleme zamanında tip güvenliği denetimlerinden geçmediği için hataları çalışma zamanında ortaya çıkarabilir. Bu da hata ayıklamayı zorlaştırabilir.
• API Değişikliklerine Duyarlılık: Eğer Reflection ile eriştiğiniz tiplerin veya üyelerin isimleri değişirse, kodunuz derleme hatası vermez ancak çalışma zamanında başarısız olur.

Sonuç

C# Reflection, programlama dünyasında dinamik ve esnek çözümler üretmek için paha biçilmez bir araçtır. Özellikle çalışma zamanında sınıf özelliklerine erişme ve onları manipüle etme yeteneği, ORM’lerden IoC konteynerlerine kadar birçok gelişmiş mimarinin temelini oluşturur. Ancak, performans üzerindeki potansiyel etkisi ve bakım zorlukları nedeniyle bilinçli ve ölçülü kullanılması gereken bir teknolojidir. Bu makalede sunulan örnekler ve açıklamalar, C# Reflection’ın gücünü anlamanıza ve kendi projelerinizde doğru bir şekilde kullanmanıza yardımcı olacaktır. Kodunuzun dinamik yeteneklerini keşfetmeye hazır olun!