Delegates மற்றும் Events என்றால் என்ன?

Question

Accepted Answer

**delegate** என்பது ஒரு method-ஐ type-safe ஆக reference செய்யும் ஒன்று (function pointer போல) — இது methods-ஐ data ஆக treat செய்ய உதவுகிறது: store செய்யுங்கள், arguments ஆக pass செய்யுங்கள், மற்றும் invoke செய்யுங்கள். **Events** என்பது delegates-ல் built on செய்யப்பட்ட ஒரு pattern ஆகும் publish-subscribe (observer) model-க்கு. அவை C#-ல் callbacks, LINQ, மற்றும் event-driven programming-ஐ support செய்கிறது. ## Delegates — methods ஆக values ```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 ``` ஒரு delegate method-ஐ reference பிடிக்கும் அதன் signature-ஐ match செய்து, methods-ஐ pass around செய்யவும் dynamically invoke செய்யவும் enable செய்கிறது. ## Built-in delegate types (இவற்றை use செய்யுங்கள், custom ones அல்ல) ```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 ``` Modern C#-ல், நீங்கள் usually **`Func<>`** (value return செய்கிறது), **`Action<>`** (void return செய்கிறது), மற்றும் `Predicate<>` என்ற built-in delegate types-ஐ use செய்யுங்கள் custom delegate types declare செய்யாமல். Lambdas (`x => ...`) delegates-ஐ create செய்கின்றன — LINQ-ன் foundation. ## Events — publish-subscribe pattern ```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 (-=) ``` ஒரு **event** ஒரு delegate-ஐ wrap செய்து safe pub-sub provide செய்கிறது: subscribers `+=` உடன் handlers register செய்கிறார்கள், publisher event-ஐ raise செய்கிறார் (`Invoke`), மற்றும் அனைத்து handlers run செய்கின்றன. Events outside code-ஐ restrict செய்கின்றன subscribing/unsubscribing மட்டும் செய்ய (raising அல்லது clearing அல்ல) — observer pattern-க்கான encapsulation. ## ஏன் இது முக்கியம் Delegates மற்றும் events முக்கியமான C# features ஆகும் methods-ஐ data ஆக treat செய்ய, callbacks, மற்றும் event-driven programming enable செய்கின்றன — மற்றும் அவற்றை understand செய்வது அவற்றை use செய்வதற்கும் C# மற்றும் .NET எவ்வாறு work செய்கிறது என்பதை புரிந்துகொள்வதற்கும் valuable. **Delegates** (type-safe method references) foundation: அவை methods-ஐ store, pass, மற்றும் dynamically invoke செய்ய allow செய்கின்றன, இது **LINQ** (lambdas `Where`/`Select`-க்கு pass செய்யப்படுபவை delegates ஆகும்), callbacks, மற்றும் functional-style programming-ஐ underpin செய்கிறது. Built-in **`Func<>`/`Action<>`/`Predicate<>`** delegate types (custom ones declare செய்யாமல்) use செய்ய knowing practical, everyday knowledge ஆகும் since அவை framework-ல் எங்கும் appear செய்கிறது மற்றும் LINQ மற்றும் many APIs-க்கு behavior pass செய்ய how you do it ஆகும். **Events** delegates-ல் build செய்து publish-subscribe (observer) pattern-ஐ safely implement செய்கிறது — அவை event-driven scenarios-ஐ handle செய்ய C# எவ்வாறு handle செய்கிறது (UI events, notifications, decoupled communication), `+=`/`-=` உடன் subscribing/unsubscribing-க்கு. Delegates (especially Func/Action மற்றும் lambdas, LINQ-ன் basis), மற்றும் events (decoupled, event-driven code-க்கான pub-sub pattern) understand செய்வது C#-ல் effectively work செய்வதற்கு முக்கியம், since இந்த features LINQ, callbacks, மற்றும் event handling-ஐ underpin செய்கின்றன constantly appear செய்கிறது. Them mastering — particularly lambdas delegates என்பதை recognize செய்வது மற்றும் அவை LINQ மற்றும் functional patterns-ஐ enable செய்ய எவ்வாறு — frequently-applied knowledge ஆகும் C#-ன் functional capabilities மற்றும் event-driven model-ஐ understand செய்வதை reflect செய்கிறது, மற்றும் ஒரு common interview topic ஆகும்.