ડેલિગેટ્સ અને ઇવેન્ટ્સ શું છે?

Question

Accepted Answer

એક **ડેલિગેટ** એ કોઈ મેથડનો ટાઈપ-સેફ રેફરન્સ છે (ફંક્શન પોઇન્ટર જેવો) — તે તમને મેથડને ડેટા તરીકે ગણવા દેય છે: તેમને સ્ટોર કરો, તેમને આર્ગ્યુમેન્ટ્સ તરીકે પાસ કરો, અને તેમને invoke કરો. **ઇવેન્ટ્સ** એ ડેલિગેટ્સ પર બનેલું એક પેટર્ન છે જે publish-subscribe (observer) મોડલ માટે છે. તે C# માં callbacks, LINQ, અને event-driven programming ને આધાર આપે છે. ## ડેલિગેટ્સ — મેથડ્સ તરીકે મૂલ્યો ```csharp // a delegate type defines a method signature public delegate int Operation(int a, int b); Operation add = (a, b) => a + b; // assign a method/lambda to it Operation multiply = (a, b) => a * b; int result = add(2, 3); // invoke → 5 // pass a delegate as an argument (higher-order function) int Apply(Operation op, int x, int y) => op(x, y); Apply(multiply, 4, 5); // 20 ``` એક ડેલિગેટ તેના સિગ્નેચર સાથે મેળ ખાતા મેથડનો રેફરન્સ રાખે છે, જે મેથડ્સને આસપાસ પાસ કરવા અને ગતિશીલ રીતે invoke કરવા માટે સક્ષમ બનાવે છે. ## બિલ્ટ-ઇન ડેલિગેટ ટાઈપ્સ (આ વાપરો, કસ્ટમ નહીં) ```csharp Func add = (a, b) => a + b; // Func — takes args, RETURNS a value Action log = msg => Console.WriteLine(msg); // Action — returns VOID Predicate isPositive = n => n > 0; // Predicate — returns bool // used heavily in LINQ and APIs: list.Where(x => x > 0).Select(x => x * 2); // lambdas are delegates ``` ાધુનિક C# માં, તમે સામાન્યતઃ બિલ્ટ-ઇન **`Func<>`** (એક મૂલ્য પરત કરે છે), **`Action<>`** (void પરત કરે છે), અને `Predicate<>` વાપરો કરો છો, કસ્ટમ ડેલિગેટ ટાઈપ્સ ઘોષણા કરવાની બજાય. લેમ્બ્ડાસ (`x => ...`) ડેલિગેટ્સ બનાવે છે — LINQ નો આધાર. ## ઇવેન્ટ્સ — publish-subscribe પેટર્ન ```csharp public class Button { public event EventHandler Clicked; // an EVENT (based on a delegate) public void Click() => Clicked?.Invoke(this, EventArgs.Empty); // raise it } var button = new Button(); button.Clicked += (sender, e) => Console.WriteLine("clicked!"); // SUBSCRIBE (+=) button.Clicked -= handler; // unsubscribe (-=) ``` એક **ઇવેન્ટ** સુરક્ષિત pub-sub આપવા માટે ડેલિગેટને લપેટે છે: subscribers `+=` સાથે હેન્ડલર્સ રજિસ્ટર કરે છે, publisher ઇવેન્ટ raise કરે છે (`Invoke`), અને બધા હેન્ડલર્સ ચાલે છે. ઇવેન્ટ્સ બાહ્ય કોડને ફક્ત subscribe/unsubscribe કરવા તક મર્યાદિત કરે છે (raise કરવા અથવા સાફ કરવા નહીં) — observer પેટર્ન માટે encapsulation. ## શા માટે તે મહત્વનું છે ડેલિગેટ્સ અને ઇવેન્ટ્સ મહત્વપૂર્ણ C# ફીચર્સ છે જે મેથડને ડેટા તરીકે ગણવાનું, callbacks, અને event-driven programming સક્ષમ બનાવે છે — અને તેમને સમજવું તેમનો ઉપયોગ કરવા અને C# અને .NET કેટલું કામ કરે છે તે સમજવા બંને માટે મૂલ્યવાન છે. **ડેલિગેટ્સ** (ટાઈપ-સેફ મેથડ રેફરન્સ્સ) આધાર છે: તે મેથડને સ્ટોર કરવા, પાસ કરવા અને ગતિશીલ રીતે invoke કરવા દેય છે, જે **LINQ** (lambda પાસ કર્યા જાય છે `Where`/`Select` માટે ડેલિગેટ્સ છે), callbacks, અને functional-style programming નો આધાર છે. બિલ્ટ-ઇન **`Func<>`/`Action<>`/`Predicate<>`** ડેલિગેટ ટાઈપ્સ વાપરવા (કસ્ટમ જાહેર કરવાની બજાય) તે પ્રાયોગિક, રોજમર્રાનું જ્ઞાન છે કારણ કે તે આખી framework માં દેખાય છે અને તમે LINQ અને ઘણા APIs માટે વર્તન પાસ કરો છો. **ઇવેન્ટ્સ** publish-subscribe (observer) પેટર્ન સુરક્ષિતપણે લાગુ કરવા માટે ડેલિગેટ્સ પર બનાવે છે — તે C# event-driven scenarios (UI events, notifications, decoupled communication) હેન્ડલ કરે છે તે તમે `+=`/`-=` સાથે subscribe/unsubscribe છો. ડેલિગેટ્સ (ખાસ Func/Action અને lambdas, LINQ નો આધાર), અને ઇવેન્ટ્સ (decoupled, event-driven કોડ માટે pub-sub પેટર્ન) સમજવું C# સાથે અસરકારક રીતે કામ કરવા માટે મહત્વપૂર્ણ છે, કારણ કે આ ફીચર્સ LINQ, callbacks, અને event handling નો આધાર તૈયાર કરે છે જે સતત દેખાય છે. તેમને માસ્ટર કરવું — ખાસ કરીને યાદ રાખવું કે lambdas ડેલિગેટ્સ છે અને તે LINQ અને functional પેટર્નો કેવી રીતે સક્ષમ બનાવે છે — તે વારંવાર-લાગુ જ્ઞાન છે જે C# ની functional capabilities અને event-driven મોડલની સમજણ પ્રતિબિંબિત કરે છે, અને તે સામાન્ય interview topic છે.