Agora Metin2 1
Agora Metin2
berzahx 1
berzahx
Aliyldrim 1
Aliyldrim
-ECD- 1
-ECD-
Reklam vermek için turkmmo@gmail.com

C# Reflection ve Öznitelik Kullanımı: typeof, GetType ve Custom Attributes

image247fbc2075bc98a7.jpg


Reflection (Yansıma) mekanizması, bir yazılımın çalışma anında kendi yapısını incelemesine olanak tanır. Bu sayede bir sınıfın hangi özelliklere (property) sahip olduğunu, içindeki metotları, değerlerin içeriğini ve nesneye iliştirilmiş öznitelikleri (attributes) program çalışırken tespit edebilirsiniz. Öznitelikler ise [Obsolete] veya [JsonPropertyName("id")] örneklerinde olduğu gibi, köşeli parantezlerle belirtilen deklaratif etiketlerdir. Bu etiketler, bir kod parçası veya derleyici onları reflection aracılığıyla okuyana kadar pasif kalırlar. ASP.NET yönlendirmeleri, ORM sistemleri, test araçları ve JSON dönüştürücüler tamamen bu yapı üzerine inşa edilmiştir.

Standart uygulama geliştirme süreçlerinde reflection kullanımına pek ihtiyaç duyulmasa da, framework'lerin arka plandaki çalışma prensiplerini kavramak için bu konuyu bilmek kritiktir.

Tip Nesnelerine Erişim: typeof ve GetType Farkı

Reflection işlemlerinin temel taşı System.Type sınıfıdır. Bir tipin bilgilerine ulaşmak için iki temel yöntem mevcuttur:

C#:
using System;

class Employee { public string Name { get; set; } }
class Manager : Employee { public int Reports { get; set; } }

class Program
{
    static void Main()
    {
        Type t1 = typeof(Employee);          // from a type name, at compile time
        Employee e = new Manager();
        Type t2 = e.GetType();               // from an object, at run time

        Console.WriteLine(t1.Name);
        Console.WriteLine(t2.Name);          // the real type, not the variable's type
        Console.WriteLine(t2.BaseType.Name);

        Console.WriteLine(e.GetType() == typeof(Employee));   // exact type check
        Console.WriteLine(e is Employee);                     // "is it an Employee or derived?"
        Console.WriteLine(typeof(Employee).IsAssignableFrom(t2));

        Console.WriteLine(typeof(int).FullName);
        Console.WriteLine(typeof(string).IsValueType);
        Console.WriteLine(nameof(Employee.Name));             // compile-time name, no reflection
    }
}

Kodu çalıştırdığınızda alacağınız sonuç:

Kod:
Employee
Manager
Employee
False
True
True
System.Int32
False
Name

Bu iki yöntem arasındaki temel fark şudur: typeof(X) ifadesi, henüz kod yazım aşamasında bilinen bir türü ifade ederken; obj.GetType() çalışma anında o nesnenin gerçekte hangi türden olduğunu sorgular. Eğer GetType() == typeof(Employee) şeklinde bir kontrol yaparsanız, bu sadece kesin eşleşmeleri bulur ve kalıtım yoluyla türetilmiş sınıfları kapsamaz. Bu nedenle miras durumlarını da dahil etmek için is anahtar kelimesi veya IsAssignableFrom metodu tercih edilmelidir. nameof ifadesi ise reflection ile karıştırılmamalıdır; o sadece derleme aşamasında ilgili ismin string karşılığını üretir.

Dikkat edilmesi gereken bir diğer nokta, null bir referans üzerinden GetType() çağrısı yapıldığında NullReferenceException hatası alınacağıdır. Ayrıca, box edilmiş bir nullable değer tipinde (örneğin int?), bu metot bize doğrudan temel tipi (System.Int32) döndürür.

Property İşlemleri: Değer Okuma ve Atama

GetProperties() metodu, bir tipteki tüm public özellikleri PropertyInfo nesneleri şeklinde listeler. Bu nesneler üzerinden belirli bir örnekteki verileri okuyabilir veya değiştirebilirsiniz:

C#:
using System;
using System.Reflection;

class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    private string supplierCode = "SUP-77";
}

class Program
{
    static void Main()
    {
        var mug = new Product { Name = "Mug", Price = 8.50m, Stock = 12 };
        Type type = mug.GetType();

        foreach (PropertyInfo p in type.GetProperties())
            Console.WriteLine($"{p.Name,-6} {p.PropertyType.Name,-8} = {p.GetValue(mug)}");

        PropertyInfo price = type.GetProperty("Price");
        price.SetValue(mug, 7.90m);
        Console.WriteLine(mug.Price);

        Console.WriteLine(type.GetProperty("Colour") == null);   // no such property

        FieldInfo hidden = type.GetField("supplierCode", BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine(hidden.GetValue(mug));
    }
}

Kodu çalıştırdığınızda alacağınız sonuç:

Kod:
Name   String   = Mug
Price  Decimal  = 8.50
Stock  Int32    = 12
7.90
True
SUP-77

Yukarıdaki örnekten çıkarılacak önemli dersler şunlardır:

• GetValue metodu geriye object döndürdüğü için, değer tipleriyle çalışırken "unboxing" yani tip dönüşümü (cast) yapmanız gerekir.
• GetProperty metoduna hatalı bir isim verirseniz null döner; bu durumda kontrol yapmadan devam etmek uygulamanın çökmesine neden olur.
• BindingFlags.NonPublic | BindingFlags.Instance parametrelerini kullanarak gizli (private) üyelere erişebilirsiniz. Bu yöntem testlerde veya özel araçlarda kullanılsa da, sınıfın iç yapısı değiştiğinde kodun sessizce bozulma riski vardır.

Bu mantık, nesneleri JSON formatına çeviren veya verileri CSV olarak dışa aktaran sistemlerin temel çalışma prensibidir.

Dinamik Metot Çağrımı ve Nesne Oluşturma

Bir metodu ismen bulup çalıştırmak için GetMethod ve Invoke ikilisi kullanılır. Activator.CreateInstance ise bir tip bilgisi üzerinden yeni bir nesne örneği üretir. Özellikle eklenti (plugin) sistemlerinde ve bağımlılık enjeksiyonu (DI) araçlarında bu yöntemden faydalanılır:

C#:
using System;
using System.Reflection;

class PriceCalculator
{
    public decimal Rate { get; set; } = 0.20m;
    public decimal WithTax(decimal net) => net * (1 + Rate);
    public string Describe() => $"Tax rate {Rate:P0}";
}

class Program
{
    static void Main()
    {
        Type type = typeof(PriceCalculator);
        object calc = Activator.CreateInstance(type);

        MethodInfo withTax = type.GetMethod("WithTax");
        object result = withTax.Invoke(calc, new object[] { 50m });
        Console.WriteLine(result);

        foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
        {
            if (m.IsSpecialName) continue;   // skip property getters and setters
            Console.WriteLine($"{m.ReturnType.Name} {m.Name}({m.GetParameters().Length} parameters)");
        }

        Type byName = Type.GetType("PriceCalculator");
        Console.WriteLine(byName == type);
    }
}

Kodu çalıştırdığınızda alacağınız sonuç:

Kod:
60.00
Decimal WithTax(1 parameters)
String Describe(0 parameters)
True

DeclaredOnly seçeneği kullanıldığında, sadece o sınıfa özgü üyeler listelenir; aksi halde ToString veya GetHashCode gibi nesne temelinden gelen tüm metotlar listeye dahil olur. Type.GetType kullanırken, eğer tip farklı bir kütüphanedeyse (assembly), namespace ile birlikte kütüphane adını da belirtmek zorunludur.

Eğer Invoke ile çağrılan metot içinde bir hata oluşursa, sistem bu hatayı doğrudan fırlatmaz; onun yerine hatayı bir TargetInvocationException içine paketler. Asıl hataya InnerException üzerinden ulaşılabilir.

Öznitelikler: Kod Üzerindeki Etiketler

Öznitelikler, ilgili kod bloklarının hemen üzerine köşeli parantez içinde yerleştirilir. Derleyici davranışlarını etkileyen bazı hazır öznitelikler şunlardır:

C#:
public class OrderService
{
    [Obsolete("Use PlaceOrderAsync instead.")]
    public void PlaceOrder(Order order) { }
    // Every call site: warning CS0618: 'OrderService.PlaceOrder(Order)' is obsolete: 'Use PlaceOrderAsync instead.'
    // [Obsolete("...", true)] makes it error CS0619 instead.

    [Conditional("DEBUG")]
    public void Trace(string message) => Console.WriteLine(message);
    // Calls to Trace are removed entirely from builds without the DEBUG symbol.
}

[Flags] enum Channels { None = 0, Email = 1, Sms = 2 }   // changes how ToString formats combinations
[Serializable] class Snapshot { }                     // marks a type for legacy binary serialization

Birçok popüler kütüphane bu yapıyı kullanır: System.Text.Json ile verileri eşleştirmek, Entity Framework ile veritabanı kurallarını belirlemek veya Unit Test framework'lerinde test metotlarını işaretlemek bunlara örnektir. Unutulmamalıdır ki öznitelik kendi başına bir işlem yapmaz; sadece onu okuyan bir kod parçası için anlam ifade eder.

C# geleneklerine göre öznitelik sınıflarının ismi Attribute ile biter ancak kod içerisinde bu son eki yazmadan kullanmanıza izin verilir.

Kendi Özniteliğinizi Tasarlamak

Özel bir öznitelik oluşturmak için Attribute sınıfından miras alan bir sınıf yazmalısınız. [AttributeUsage] ile bu etiketin nerelerde (sınıf, metot vb.) kullanılabileceğini sınırlandırabilirsiniz. Constructor üzerinden zorunlu parametreler, property'ler üzerinden ise isteğe bağlı adlandırılmış parametreler tanımlanabilir:

C#:
using System;
using System.Collections.Generic;
using System.Reflection;

[AttributeUsage(AttributeTargets.Property)]
class RequiredAttribute : Attribute { }

[AttributeUsage(AttributeTargets.Property)]
class MaxLengthAttribute : Attribute
{
    public int Length { get; }
    public string Message { get; set; }            // optional, set as a named argument
    public MaxLengthAttribute(int length) { Length = length; }
}

class SignupForm
{
    [Required, MaxLength(20)]
    public string Username { get; set; }

    [Required]
    public string Email { get; set; }

    [MaxLength(10, Message = "Keep the city code short")]
    public string CityCode { get; set; }
}

static class Validator
{
    public static List<string> Validate(object model)
    {
        var errors = new List<string>();
        foreach (PropertyInfo p in model.GetType().GetProperties())
        {
            var value = p.GetValue(model) as string;

            if (p.GetCustomAttribute<RequiredAttribute>() != null && string.IsNullOrWhiteSpace(value))
                errors.Add($"{p.Name} is required");

            var max = p.GetCustomAttribute<MaxLengthAttribute>();
            if (max != null && value != null && value.Length > max.Length)
                errors.Add(max.Message ?? $"{p.Name} must be at most {max.Length} characters");
        }
        return errors;
    }
}

class Program
{
    static void Main()
    {
        var form = new SignupForm { Username = "a_very_long_username_indeed", CityCode = "LISBON-CENTRAL" };
        foreach (var error in Validator.Validate(form))
            Console.WriteLine(error);

        var ok = new SignupForm { Username = "ana", Email = "ana@example.com", CityCode = "LIS" };
        Console.WriteLine(Validator.Validate(ok).Count);
    }
}

Kodu çalıştırdığınızda alacağınız sonuç:

Kod:
Username must be at most 20 characters
Email is required
Keep the city code short
0

Bu yapı, büyük framework'lerin doğrulama sistemlerinin basitleştirilmiş bir halidir. Öznitelik parametreleri sabit değerler olmak zorundadır (string, int, enum gibi); çünkü bu bilgiler doğrudan assembly meta verisine işlenir. GetCustomAttribute<T> metodu ile bu verilere ulaşılabilir.

Reflection Kullanımının Getirileri ve Götürüleri

Reflection esneklik sağlar ancak beraberinde bazı maliyetler getirir:

• Performans: İsimle üye aramak ve dinamik çağrı yapmak, doğrudan kod çağırmaya göre oldukça yavaştır. Sık kullanılan işlemlerde metot bilgilerini önbelleğe almak veya delegate'lere dönüştürmek performansı artırır.
• Güvenlik ve Hatalar: Yazım hataları derleme anında değil, uygulama çalışırken hata verir. "Sihirli stringler" yerine nameof kullanarak bu riski azaltabilirsiniz.
• Modern Teknolojiler: Native AOT ve uygulama boyutu küçültme (trimming) işlemleri, reflection ile ulaşılan kodları "kullanılmıyor" sanarak silebilir. Bu yüzden modern kütüphaneler artık "Source Generator" yapısına geçiş yapmaktadır.

Genel kural olarak; eğer tip bilgilerini önceden biliyorsanız interface veya generic yapıları kullanın; reflection'ı sadece tipin önceden bilinmediği eklenti veya genel araç senaryoları için saklayın.

Sık Yapılan Hatalar

• Tip kontrolü yaparken GetType() == typeof(X) kullanmak (miras alınan sınıfları kaçırmanıza sebep olur).
• GetMethod gibi arama sonuçlarında null kontrolü yapmayı atlamak.
• Yoğun döngüler içerisinde önbellekleme yapmadan sürekli reflection çağırmak.
• Invoke hatalarını yakalarken InnerException'a bakmamak.
• Özellik veya metot isimlerini string olarak elle yazmak (nameof kullanılması önerilir).
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst