Cad iad delegates agus events?

Question

Accepted Answer

Is **delegate** ann ná tagairt chineál-dhíonach do dhóigh (cosúil le pointeoir feidhme) — tugann sé deis duit dóighanna a bhreithniú mar shonraí: iad a stóráil, iad a rá mar argóintí, agus iad a ghlaoiseach. Is **events** ann ná patrún atá bunaithe ar delegates do mhúnla foilsithe-foscríofa (observer). Tá siad mar bhunús ar callbacks, LINQ, agus clár-dhíonach atá tiomantach ar events i C#. ## Delegates — dóighanna mar luachanna ```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 ``` Coimeádann delegate tagairt do dhóigh a bhaineann lena síniú, rud a chuireann ar chumas dóighanna a bheith á bhogadh timpeall agus á n-agairt go dinimiciúil. ## Cineálacha delegate ionsuite (úsáid iad seo, ní cinn dhúnta) ```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 ``` I C# nua-aimseartha, is gnách go n-úsáideann tú na **`Func<>`** ionsuite (toradh ar ais), **`Action<>`** (void ar ais), agus `Predicate<>` seachas cineálacha delegate dhúnta a dhearbhú. Cruthú delegates a dhéanann lambdas (`x => ...`) — bunús LINQ. ## Events — an patrún foilsithe-foscríofa ```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 (-=) ``` Is **event** ann rud a bhíonn ag foluain timpeall ar delegate chun pub-sub sábháilte a sholáthar: cláraitheoir dhréachtanna le `+=`, an foilsitheoir a thógann an event (`Invoke`), agus rith gach fhreagra. Srianaíonn events cód taobh amuigh ó rud ar bith a dhéanamh ach foscríobh/díchláir (gan a ardú ná a gheal) — encapsulation don phatrún observer. ## Cén fáth a bhfuil sé tábhachtach Is gné thábhachtach C# iad delegates agus events a chuireann ar chumas dóighanna a bhreithniú mar shonraí, callbacks, agus clár atá tiomantach ar events — agus tá sé fiúntach an méid atá tuigthe agat fúthu ó thaobh úsáide agus ó thaobh tuisceana ar conas a oibríonn cuid mhór de C# agus .NET. Is bunús iad **Delegates** (tagairt ar dhoigh chineál-dhíonach): tugann siad deis dóighanna a bheith stóráilte, rá, agus agairt go dinimiciúil, rud a thugann bunús do **LINQ** (lambdas a rá go `Where`/`Select` iad delegates), callbacks, agus clárú i stíl fheidhmiúil. Is eolas praiticiúil, laethúil é a bheith ar an eolas go n-úsáideann tú na **`Func<>`/`Action<>`/`Predicate<>`** cineálacha delegate ionsuite (in ionad cinn dhúnta a dhearbhú) ó tharla go bhfuil siad le feiceáil i gcoitinne tríd an bhfráimh agus is sin mar a thugann tú iompar go LINQ agus go leor APIs. Tóg **Events** ar delegates chun an patrún foilsithe-foscríofa (observer) a chur i bhfeidhm go sábháilte — seo an chaoi a ndéileálann C# le drochdhúile atá tiomantach ar events (UI events, fógraí, cumarsáid dhíchuibhithe), le `+=`/`-=` d'fhoscríobh/díchláir. Tá sé tábhachtach tuiscint a bheith agat ar delegates (go háirithe Func/Action agus lambdas, bunús LINQ), agus events (an patrún pub-sub do chód díchuibhithe atá tiomantach ar events) ar feadh oibre éifeachtúil le C#, ó tharla go bhfuil na gné seo mar bhunús do LINQ, callbacks, agus láimhseáil events a bhíonn ann i gcoitinne. An mastery orthu — go háirithe tugtha faoi deara gur delegates iad lambdas agus conas a chuireann siad ar chumas LINQ agus patrúin fheidhmiúla — is eolas minic-úsáidte é a léiríonn tuiscint ar na cabálacha feidhmiúla agus ar mhúnla atá tiomantach ar events de C#, agus is ábhar comhghairm comhaid a bhíonn ann.