రిఫ్లెక్షన్ ఒక ప్రోగ్రామ్ను రানटైమ్లో టైపులు, మెథడ్లు మరియు ప్రాపర్టీలను పరిశీలించడం మరియు మార్చడం సక్షమ చేస్తుంది — కంపైల్ టైమ్లో తెలియని వాటితో కూడా. ఆట్రిబ్యూట్లు కోడ్కు ప్రకటనాత్మక మెటాడేటా జతపరుస్తాయి, టూల్లు మరియు ఫ్రేమ్వర్క్లు (తరచుగా రిఫ్లెక్షన్ ద్వారా) చదువుతాయి ఆ ప్రవర్తనను నడిపిస్తాయి. కలిసి అవి .NET యొక్క ఫ్రేమ్వర్క్ "మ్యాజిక్" యొక్క చాలా భాగాలను శక్తిచేస్తాయి (సీరియలైజేషన్, DI, ORMs, ధృవీకరణ).
// 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
రిఫ్లెక్షన్ కోడ్ను టైపులను డైనమికల్గా గుర్తించుకోవడం మరియు ఉపయోగించడం సక్షమ చేస్తుంది — టైపు ద్వారా ఇన్స్టాన్షియేట్ చేయడం, ప్రాపర్టీలను చదువడం/సెట్ చేయడం, మెథడ్లను ఆహ్వానించడం — ఇది ఫ్రేమ్వర్క్లు ముందుగానే తెలియని మీ టైపులపై ఎలా కంటే అందుకు.
// 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) { }
ఆట్రిబ్యూట్లు కోడ్ను మెటాడేటాతో శంకరించాయి, ఫ్రేమ్వర్క్లు ప్రవర్తనను నడిపిస్తాయి — ధృవీకరణ నియమాలు, సీరియలైజేషన్ పేర్లు, రూటింగ్, మొదలైనవి.
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]), ధృవీకరణ ([Required]), సీరియలైజేషన్ ([JsonPropertyName]), ORMs, మరియు టెస్టింగ్ ఫ్రేమ్వర్క్ల వెనుక ఉన్న విధానం — అవి రిఫ్లెక్షన్ ద్వారా ఆట్రిబ్యూట్ చేసిన కోడ్ను స్కాన్ చేస్తాయి మరియు ప్రవర్తనను కనెక్ట్ చేస్తాయి.
రిఫ్లెక్షన్ మరియు ఆట్రిబ్యూట్లు .NET యొక్క ఫ్రేమ్వర్క్ కార్యాచరణ యొక్క చాలా భాగాల వెనుక ఉన్న యంత్రాయం, కాబట్టి వాటిని అర్థం చేసుకోవడం ఫ్రేమ్వర్క్లు ఎలా పని చేస్తాయో అర్థం చేసుకోవడానికి మరియు అధునాతన సన్నివేశాల కోసం విలువైనది. రిఫ్లెక్షన్ జెనెరిక్, డైనమిక్ ప్రవర్తనను ఉంటుంది — కంపైల్-టైమ్ జ్ఞానం లేకుండా రానటైమ్లో టైపులను పరిశీలించడం మరియు ఆపరేట్ చేయడం — ఇది డిపెండెన్సీ ఇంజెక్షన్, సీరియలైజేషన్ (JSON/XML లైబ్రరీలు ప్రాపర్టీలను చదువుతున్నాయి), ORMs (డేటాబేస్ పట్టికలకు అబ్జెక్ట్లను మ్యాపింగ్), మరియు టెస్టింగ్ ఫ్రేమ్వర్క్లు మీ ఏకపక్ష టైపులపై ఎలా పని చేస్తాయో. ఆట్రిబ్యూట్లు ఈ టూల్లు (రిఫ్లెక్షన్ ద్వారా) చదువుకున్న ప్రకటనాత్మక మెటాడేటాను సরఫరా చేస్తాయి వారి ప్రవర్తనను నడిపిస్తాయి, సూచిస్తాయి ([Required] ధృవీకరణ కోసం, [HttpGet] రూటింగ్ కోసం, [JsonPropertyName] సీరియలైజేషన్ కోసం, [Authorize] భద్రత కోసం).
వాటిని అర్థం చేసుకోవడం ASP.NET Core, Entity Framework, ధృవీకరణ, సీరియలైజేషన్, మరియు టెస్టింగ్ ఫ్రేమ్వర్క్లను ఎలా ప్రకటనాత్మక "మ్యాజిక్" సాధిస్తాయో రహస్యమुక్త చేస్తుంది — ఆట్రిబ్యూట్లు కోడ్కు గుర్తు పెట్టాయని మరియు రిఫ్లెక్షన్ ఆ గుర్తులను చదువుకుని పనిచేస్తుందని గుర్తిస్తుంది.
ఈ జ్ఞానం ఈ ఫ్రేమ్వర్క్లను సమర్థవంతంగా ఉపయోగించడానికి విలువైనది, మీ స్వంత ఫ్రేమ్వర్క్-సమ్మిళితమైన టూల్లు లేదా లైబ్రరీలను నిర్మించడం (కస్టమ్ ఆట్రిబ్యూట్లు + రిఫ్లెక్షన్), మరియు ట్రేడ్ఆఫ్లను అర్థం చేసుకోవడం (రిఫ్లెక్షన్ నేరుగా కాల్ల కంటే నెమ్మదిగా ఉంటుంది మరియు కొన్ని కంపైల్-టైమ్ చెక్లను దాటిపోయేస్తుంది, కాబట్టి ఇది జుడిషియస్గా ఉపయోగించబడుతుంది).
eadon అధునాతన మరియు రోజువారీ కోడింగ్ కాదు, రిఫ్లెక్షన్ మరియు ఆట్రిబ్యూట్లను అర్థం చేసుకోవడం .NET ఈకోసిస్టమ్లో లోతుగా పని చేయడానికి ముఖ్యమైన సీనియర్-స్థర నిపుణతకు సంబంధించినది — ఇది మీరు ప్రతిదిన ఉపయోగించే ఫ్రేమ్వర్క్లు నిజానికి ఎలా పని చేస్తాయో వివరిస్తుంది, అధునాతన మెటాప్రోగ్రామింగ్ను ఉంటుంది, మరియు .NET యొక్క ఆర్కిటెక్చర్ను అర్థం చేసుకోవడం మరియు విస్తరించదగిన, ఆట్రిబ్యూట్-నడిచిన లైబ్రరీలను నిర్మించడం కోసం సంబంధితమైన విషయం, ఇది గভీర .NET అర్థంతో డెవలపర్లను వేరు చేసే విలువైన జ్ఞానం.