Reflection மற்றும் attributes எவற்றிற்காக பயன்படுத்தப்படுகின்றன?

Question

Accepted Answer

**Reflection** ஒரு நிரல்பணியை **வகைகள், முறைகள், மற்றும் பண்புகளை runtime-ல் ஆய்வு செய்ய மற்றும் கையாள** அனுமதிக்கிறது — தொகுக்கும் நேரத்தில் தெரியாதவை கூட. **Attributes** குறியீட்டில் பறக்கும் **metadata** இணைக்கிறது, அதை கருவிகள் மற்றும் கাட்டமைப்புகள் (பெரும்பாலும் reflection மூலம்) நடத்தையை உயர்த்த பயன்படுத்துகின்றன. ஒன்றாக அவை .NET இன் காட்டமைப்பு "அந்திரங்கள்" பெரும்பகுதியை இயக்குகின்றன (serialization, DI, ORMs, validation).

## Reflection — runtime ஆய்வு மற்றும் அழைப்பு

```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 குறியீட்டை வகைகளை மாறும்விதமாக கண்டுபிடிக்க மற்றும் பயன்படுத்த அனுமதிக்கிறது — வகையை உடனடியாக உருவாக்கு, பண்புகளை படி/எழுது, முறைகளை அழைப்பு — இது காட்டமைப்புகள் முன்கூட்டியে தெரியாமல் *உங்கள்* வகைகளை எவ்வாறு இயக்குகின்றன என்பதாகும்.

## Attributes — பறக்கும் 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 குறியீட்டை நடத்தையை இயக்கு metadata உடன் விளக்குகிறது — validation விதிகள், serialization பெயர்கள், routing, முதலியவை.

## Custom attributes + reflection (காட்டமைப்புகள் எவ்வாறு வேலை செய்கின்றன)

```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 காட்டமைப்புகளுக்கு பின்னால் உள்ள பொறிமுறையாகும் — அவை பறக்கும் குறியீட்டை reflection மூலம் ஸ்கேன் செய்து நடத்தையை வேற்றுதல்.

## இது ஏன் முக்கியமாக இருக்கிறது

Reflection மற்றும் attributes .NET இன் காட்டமைப்பு செயல்பாட்டின் பெரும்பகுதியின் **இயந்திரங்கள்**, எனவே அவற்றைப் புரிந்துகொள்வது காட்டமைப்புகள் எவ்வாறு வேலை செய்கின்றன என்பதைப் புரிந்துகொள்வதற்கும் மேம்பட்ட சூழ்நிலைகளுக்கும் மূல்யமாக இருக்கிறது. **Reflection** பொது, மாறும் நடத்தையை இயக்குகிறது — runtime-ல் தொகுக்கும் நேர ஞ்ஞானம் இல்லாமல் வகைகளை ஆய்வு செய்து இயக்குதல் — dependency injection, serialization (JSON/XML நூலகங்கள் பண்புகளை படிக்கும்), ORMs (பொருள்களை தரவுத்தள அட்டவணைகளுக்கு வரைபடமாக்குவது), மற்றும் testing காட்டமைப்புகள் உங்கள் தன்னிச்சையான வகைகளில் எவ்வாறு வேலை செய்கின்றன. **Attributes** இந்த கருவிகள் தங்கள் நடத்தையை இயக்க வாசிக்கும் (reflection மூலம்) பறக்கும் metadata வழங்குகின்றன, verbose உள்ளமைவு எளிய விளக்கங்களால் மாற்றுகிறது (`[Required]` validation-க்கு, `[HttpGet]` routing-க்கு, `[JsonPropertyName]` serialization-க்கு, `[Authorize]` பாதுகாப்புக்கு).
\