પ્રતિબિંબ (Reflection) એ પ્રોગ્રામને રનટાઇમ પર પ્રકારો, પદ્ધતિઓ અને ગુણધર્મોનું નિરીક્ષણ અને હેરફેર કરવા દે છે — તે પણ જે સમય બાંધતી વેળાએ અજાણ્યા હોય. લક્ષણો (Attributes) કોડમાં ઘોષણાત્મક મેટાડેટા જોડે છે જે સાધનો અને ફ્રેમવર્ક્સ (ઘણીવાર પ્રતિબિંબ દ્વારા) વાંચે છે અને તેનો ઉપયોગ કરીને વર્તણૂક ચલાવે છે. એક સાથે તેઓ .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, માન્યતા, સીરિયલાઇજેશન અને પરીક્ષણ ફ્રેમવર્ક્સ તેમના ઘોષણાત્મક "જાદુ" કેવી રીતે હાંસલ કરે છે તે સ્પષ્ટ કરે છે — જે અનુભવ કરે છે કે લક્ષણો કોડને નિશાન બનાવે છે અને પ્રતિબિંબ વાંચે છે અને તે નિશાનો પર કાર્ય કરે છે.
યો જ્ઞાન આ ફ્રેમવર્ક્સને અસરકારક રીતે વપરાવવા, તમારા પોતાના ફ્રેમવર્ક જેવા સાધનો અથવા લાઇબ્રેરીઓ બનાવવા (કસ્ટમ લક્ષણો + પ્રતિબિંબ), અને ટ્રેડ-ઓફ્સ સમજવા (પ્રતિબિંબ સીધા આમંત્રણો કરતાં ધીમું છે અને કેટલાક સમય-બાંધતી ચેકીંગ કોણ પાસ કરે છે, તેથી તેનો ઉપયોગ સાવધાનીથી થાય છે) માટે મૂલ્યવાન છે.
જ્યારે અદ્યતન અને દૈનિક કોડિંગ નથી, પ્રતિબિંબ અને લક્ષણોને સમજવું .NET ઇકોસિસ્ટમમાં ગહન કામ કરવા માટે મહત્ત્વપૂર્ણ વરિષ્ઠ-સ્તરનું જ્ઞાન છે — તે સમજાવે છે કે તમે દૈનિક વપરાતા ફ્રેમવર્ક્સ વાસ્તવમાં કેવી રીતે કાર્ય કરે છે, અદ્યતન મેટાપ્રોગ્રામિંગ સક્ષમ કરે છે, અને .NET ની આર્કિટેક્ચર સમજવા અને વિસ્તૃત, લક્ષણ-આધારિત લાઇબ્રેરીઓ બનાવવા માટે પ્રાસંગિક વિષય છે, જે તેને ફ્રીક્વેન્ટ જ્ઞાન બનાવે છે જે ગહન .NET સમજવા વાળા ડેવલપર્સને અલગ પાડે છે.