Reflection اور attributes کس لیے استعمال ہوتے ہیں؟

Question

Accepted Answer

**Reflection** ایک پروگرام کو **runtime پر types، methods، اور properties کو inspect اور manipulate کرنے** کی اجازت دیتا ہے — یہاں تک کہ وہ بھی جو compile time پر معلوم نہ ہوں۔ **Attributes** code کو declarative **metadata** سے منسلک کرتے ہیں جو tools اور frameworks پڑھتے ہیں (اکثر reflection کے ذریعے) تاکہ behavior کو چلایا جا سکے۔ یہ دونوں مل کر .NET کے framework "magic" کے بڑے حصے کو طاقت دیتے ہیں (serialization، DI، ORMs، validation)۔

## Reflection — runtime inspection اور invocation

```csharp
// examine a type's structure at runtime
Type type = typeof(User);
foreach (PropertyInfo prop in type.GetProperties())
    Console.WriteLine($"{prop.Name}: {prop.PropertyType}");

foreach (MethodInfo method in type.GetMethods()) { }

// create instances and invoke members dynamically
object instance = Activator.CreateInstance(type);   // create without knowing the type at compile time
PropertyInfo p = type.GetProperty("Name");
p.SetValue(instance, "Ann");                         // set a property reflectively
```

Reflection کوڈ کو dynamically types کو دریافت اور استعمال کرنے دیتا ہے — type سے instantiate کریں، properties پڑھیں/سیٹ کریں، methods invoke کریں — یہ وہی طریقہ ہے جس سے frameworks آپ کی types پر کام کرتے ہیں بغیر انہیں پہلے سے جانے۔

## Attributes — declarative metadata

```csharp
// built-in and framework attributes attach metadata to code
[Obsolete("Use NewMethod instead")]
[Serializable]
public class OldClass { }

public class User
{
    [Required]                          // validation attribute (ASP.NET)
    [StringLength(100)]
    public string Name { get; set; }

[JsonPropertyName("email_address")]  // serialization attribute
    public string Email { get; set; }
}

[HttpGet("/users/{id}")]                 // ASP.NET routing attribute
public User Get(int id) { }
```

Attributes code کو metadata سے annotate کرتے ہیں جو frameworks پڑھتے ہیں تاکہ behavior کو چلایا جا سکے — validation rules، serialization names، routing، وغیرہ۔

## Custom attributes + reflection (frameworks کیسے کام کرتے ہیں)

```csharp
public class AuditAttribute : Attribute { public string Action; }

[Audit(Action = "delete")]
public void DeleteUser(int id) { }

// a framework reads the attribute via reflection and acts on it
var attr = method.GetCustomAttribute<AuditAttribute>();
if (attr != null) Log(attr.Action);   // wrap/log/intercept based on the metadata
```

یہ ASP.NET (`[HttpGet]`، `[Authorize]`)، validation (`[Required]`)، serialization (`[JsonPropertyName]`)، ORMs، اور testing frameworks کے پیچھے کا نظام ہے — وہ reflection کے ذریعے attributed code کو scan کرتے ہیں اور behavior کو wire اپ کرتے ہیں۔

## اس کی اہمیت

Reflection اور attributes .NET کی framework functionality کے **بہت سے حصوں کے پیچھے کی machinery ہیں**، تو ان کو سمجھنا قیمتی ہے frameworks کے کام کرنے کا طریقہ سمجھنے کے لیے اور advanced scenarios کے لیے۔ **Reflection** generic، dynamic behavior کو قابل بناتا ہے — runtime پر types کو inspect اور operate کرنا compile-time knowledge کے بغیر — یہی طریقہ ہے جس سے dependency injection، serialization (JSON/XML libraries properties پڑھتی ہیں)، ORMs (objects کو database tables سے map کرتے ہیں)، اور testing frameworks آپ کی arbitrary types پر کام کرتے ہیں۔ **Attributes** declarative metadata فراہم کرتے ہیں جو یہ tools پڑھتے ہیں (reflection کے ذریعے) تاکہ اپنا behavior چلا سکیں، verbose configuration کی جگہ سادہ annotations لیتے ہیں (`[Required]` validation کے لیے، `[HttpGet]` routing کے لیے، `[JsonPropertyName]` serialization کے لیے، `[Authorize]` security کے لیے)۔
un کو سمجھنا **ASP.NET Core، Entity Framework، validation، serialization، اور testing frameworks کے declarative "magic" کو واضح کرتا ہے** — یہ recognize کرتے ہوئے کہ attributes code کو mark کرتے ہیں اور reflection ان marks کو پڑھتا ہے اور ان پر عمل کرتا ہے۔

یہ علم ان frameworks کو مؤثر طریقے سے استعمال کرنے کے لیے قیمتی ہے، اپنی اپنی framework جیسی tools یا libraries بنانے کے لیے (custom attributes + reflection)، اور trade-offs کو سمجھنے کے لیے (reflection براہ راست calls سے سست ہے اور کچھ compile-time checking کو bypass کرتا ہے، تو یہ احتیاط سے استعمال ہوتا ہے)۔

حالانکہ یہ advanced ہے اور روزمرہ کی coding نہیں ہے، reflection اور attributes کو سمجھنا senior-level علم ہے .NET ecosystem میں گہری کام کے لیے — یہ بتاتا ہے کہ وہ frameworks جو آپ روزانہ استعمال کرتے ہیں اصل میں کیسے کام کرتے ہیں، advanced metaprogramming کو قابل بناتا ہے، اور .NET کے architecture کو سمجھنے کے لیے متعلقہ موضوع ہے اور extensible، attribute-driven libraries بنانے کے لیے، یہ قابل قدر علم بناتے ہوئے جو deep .NET understanding والے developers کو الگ کرتا ہے۔