C# में रिफ्लेक्शन का उपयोग करके प्रॉपर्टी मान कैसे सेट करें

System.Reflection नेमस्पेस में वे क्लासेस होती हैं जो आपको एप्लिकेशन के बारे में जानकारी प्राप्त करने और एप्लिकेशन में डायनामिक रूप से टाइप्स, मान और ऑब्जेक्ट्स जोड़ने की अनुमति देती हैं।

रिफ्लेक्शन ऑब्जेक्ट्स का उपयोग रनटाइम पर टाइप जानकारी प्राप्त करने के लिए किया जाता है। रनिंग प्रोग्राम के मेटाडेटा तक पहुंच देने वाली क्लासेस System.Reflection नेमस्पेस में हैं।

मुख्य रिफ्लेक्शन मेथड्स

• GetProperty(String) - निर्दिष्ट नाम के साथ पब्लिक प्रॉपर्टी खोजता है
• GetType(String, Boolean) - असेंबली इंस्टेंस में निर्दिष्ट नाम के साथ Type ऑब्जेक्ट प्राप्त करता है
• SetValue(Object, Object) - निर्दिष्ट ऑब्जेक्ट के प्रॉपर्टी मान को सेट करता है

उदाहरण: रिफ्लेक्शन के साथ प्रॉपर्टी सेट करें

using System;
using System.Reflection;

class Program
{
    static void Main(string[] args)
    {
        User user = new User();
        Type type = user.GetType();
        
        // प्रॉपर्टी जानकारी प्राप्त करें
        PropertyInfo prop = type.GetProperty("Name");
        
        // प्रॉपर्टी मान सेट करें
        prop.SetValue(user, "Bangalore", null);
        
        Console.WriteLine(user.Name); // आउटपुट: Bangalore
        Console.ReadLine();
    }
}

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

आउटपुट

Bangalore

उन्नत: जेनेरिक सेटर

public static class ReflectionExtensions
{
    public static void SetPropertyValue<T, TValue>(this T obj, string propertyName, TValue value)
    {
        if (obj == null) throw new ArgumentNullException(nameof(obj));
        if (string.IsNullOrEmpty(propertyName)) throw new ArgumentNullException(nameof(propertyName));
        
        var property = typeof(T).GetProperty(propertyName, 
            BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
        
        if (property == null)
            throw new ArgumentException($"Property '{propertyName}' not found on type {typeof(T).Name}");
        
        if (!property.CanWrite)
            throw new InvalidOperationException($"Property '{propertyName}' is read-only");
        
        property.SetValue(obj, value);
    }
    
    // निजी/प्रोटेक्टेड प्रॉपर्टी के लिए
    public static void SetPropertyValueNonPublic<T, TValue>(this T obj, string propertyName, TValue value)
    {
        var property = typeof(T).GetProperty(propertyName, 
            BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase);
        
        property?.SetValue(obj, value);
    }
}

// उपयोग
var user = new User();
user.SetPropertyValue("Name", "Bangalore");
user.SetPropertyValue("Id", 42);

एक्सेप्शन हैंडलिंग

try
{
    PropertyInfo prop = type.GetProperty("NonExistent");
    if (prop == null)
    {
        Console.WriteLine("Property not found");
        return;
    }
    
    prop.SetValue(user, "Value");
}
catch (ArgumentException ex)
{
    Console.WriteLine($"Invalid argument: {ex.Message}");
}
catch (TargetException ex)
{
    Console.WriteLine($"Target error: {ex.Message}");
}
catch (TargetInvocationException ex)
{
    Console.WriteLine($"Property setter threw: {ex.InnerException?.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected: {ex.Message}");
}

प्रदर्शन नोट

• रिफ्लेक्शन डायरेक्ट प्रॉपर्टी एक्सेस से धीमा है
• हॉट पथ्स के लिए, Delegate.CreateDelegate या एक्सप्रेशन ट्रीज़ का उपयोग करके कंपाइल करें
• कैश PropertyInfo ऑब्जेक्ट्स यदि बार-बार एक्सेस कर रहे हैं

कैश्ड रिफ्लेक्शन उदाहरण

public static class FastPropertyAccessor
{
    private static readonly ConcurrentDictionary<string, PropertyInfo> _cache = new();
    
    public static void SetValue<T>(T obj, string propertyName, object value)
    {
        var key = $"{typeof(T).FullName}.{propertyName}";
        var prop = _cache.GetOrAdd(key, _ => 
            typeof(T).GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance));
        
        if (prop == null) throw new ArgumentException($"Property not found: {key}");
        prop.SetValue(obj, value);
    }
}