.NETOOP and C# basicsReported by candidates

What are delegates, Func and Action, and events? Where have you used them?

Asked in first technical rounds at Infosys (three reports), Wipro, Cognizant, Deloitte and Mindfire; latest report October 2026.

Say this first · about 30 seconds

A delegate is a type-safe reference to a method. Type-safe means the compiler only lets in methods with the right parameters and return type. You can store a method in a variable, pass it to another method, and call it later.
Func and Action are the built-in delegate types: Func returns a value, Action returns nothing. I use Func every day in LINQ, for example a Where filter.
An event is a delegate the owning class wraps, so outside code can only subscribe or unsubscribe, and only the owner can raise it.
In our contract service, activation raises an Activated event, and the welcome mail and ledger posting subscribe to it. The rule: when the publisher lives longer than the subscriber, unsubscribe, or the publisher keeps it in memory and keeps calling it.

Make it yours · Navistar collections queue (invented example)

Situation: at Navistar Financial the collections team decides each morning which truck accounts get a phone call. Their rules kept changing: over 30 days late, owing more than 500, not in bankruptcy, and new ones every month.
What I did: I stored each rule as a in a list. runs every rule on an account and calls only if all say yes. A new rule is one line where the list is built.
Result: the queue class stopped changing every sprint. Each rule is a lambda you can test on its own, and the team could read the list.
What I'd say: I used delegates to make rules data, not code paths. Once a rule needed a database lookup, I'd move it behind an interface so DI could build it.

The code, simplified

Invented to show the shape, in C#. Tap Next to walk account T-881 through the rules.

Navistar.sln · where these 2 files sit

Jobs/

Diagram · step 1The job stores three rules as delegates and hands the list to the queue.

Morning job07:00

CollectionsQueue

Rules3 Funcs

new CollectionsQueue(rules)

MorningCallJob.cs · line 1 · 1 of 4Called at 07:00 by the morning job.

Fix later in your repo The rule list is built in code; a later step could load rule settings from config.

Say it out loud, then check

Show the 30-second answer

A delegate is a type-safe reference to a method. Type-safe means the compiler only lets in methods with the right parameters and return type. You can store a method in a variable, pass it to another method, and call it later.
Func and Action are the built-in delegate types: Func returns a value, Action returns nothing. I use Func every day in LINQ, for example a Where filter.
An event is a delegate the owning class wraps, so outside code can only subscribe or unsubscribe, and only the owner can raise it.
In our contract service, activation raises an Activated event, and the welcome mail and ledger posting subscribe to it. The rule: when the publisher lives longer than the subscriber, unsubscribe, or the publisher keeps it in memory and keeps calling it.

Check your answer: tick what you said

A delegate is a type-safe reference to a method: a fixed parameter list and return type, plus the target object for an instance method.
Primary use: pass behaviour as a parameter (callbacks, LINQ, rule lists) and decouple a publisher from its listeners (events).
returns a value, returns void, returns bool. They replace most custom declarations.
Delegates are multicast: += adds a method to the invocation list, -= removes it; calling it runs each in order on the same thread.
An event wraps a delegate: outside code can only += and -=; only the owning class can raise it or clear it.
Raise safely with ?.Invoke(this, args); with no subscribers the event is null.
A subscriber that never unsubscribes stays alive (the publisher holds a reference to it) and keeps getting called.
Where you use them: LINQ ( takes a ), callbacks, minimal API handlers, in middleware, and events inside one process.
Across services or processes, use a message queue (Azure ), not C# events.

You said 0 of 9

Then add your example: Navistar collections queue (invented example)

Situation: at Navistar Financial the collections team decides each morning which truck accounts get a phone call. Their rules kept changing: over 30 days late, owing more than 500, not in bankruptcy, and new ones every month.
What I did: I stored each rule as a in a list. runs every rule on an account and calls only if all say yes. A new rule is one line where the list is built.
Result: the queue class stopped changing every sprint. Each rule is a lambda you can test on its own, and the team could read the list.
What I'd say: I used delegates to make rules data, not code paths. Once a rule needed a database lookup, I'd move it behind an interface so DI could build it.

See it

ContractActivatorcalls each one by name

MailerWelcomeMailer: welcome pack

LedgerLedgerPoster: posting

1/7Before: activation calls the mailer and the ledger itself, by name.

In plain words

A delegate is a phone number saved in your contacts. You don't call the person now; you keep the number, hand it to someone else, and they call later. Type-safe means the contact card also says how the person answers (what they need, what they give back), and the compiler refuses a number that doesn't match.
A number alone isn't enough when many people share a desk phone: you also need whose extension it is. That's why a delegate to an ordinary method stores two things: the object (whose desk) and the method (which task to do).
Func and Action are ready-made contact types, so you don't define your own. They are generic: you fill in the types in angle brackets. takes a and gives back a bool (the last type is always what comes back). takes a string and gives back nothing.
A lambda is a small method written in place, with no name: c => c.DaysOverdue > 30 reads "given c, return whether c is more than 30 days late". The left of => is the input, the right is the result.
An event is a newsletter. People sign up (+=) and sign off (-=). Behind the scenes the sign-up list is a list of delegates, called the invocation list. Only the newsletter's owner can send an issue (raise the event), and readers can't delete each other from the list.
The catch: the newsletter keeps your address until you sign off. In code, while the publisher's list holds a reference to your object, .NET can't free it from memory, and it keeps getting called.

The senior answer · about 2 minutes

What they are

A delegate is a type that describes a method's shape: what it takes and what it returns. A variable of that type holds a method, plus, for an instance method, the object it should run on (a static method has none). The compiler checks the shape, so you can't put a method with the wrong parameters in it. That's what type-safe means here.
I almost never declare my own type now. covers every method that returns something, covers every method that returns nothing, and is an older one for yes or no checks. The custom keyword still shows up in old code and in some framework types like .
Every delegate is multicast. += adds a method to its invocation list, which is just the list of methods it will call. Calling the delegate runs each one in order, on the caller's thread, one after another.

Why events exist

If a class exposed a public delegate field, any outside code could set it to null and wipe every subscriber, or call it and pretend the thing happened. The keyword closes both holes: from outside you can only += and -=; only the owning class can raise it.
The point is decoupling. The class that activates a contract doesn't know who cares. Mail, the ledger and later an SMS sender subscribe themselves, and the activation code never changes when a new reaction is added.
The standard shape is : the sender, and an object carrying the data. I raise it with ?.Invoke, because an event with no subscribers is null.

Where it goes wrong

Leaks. The publisher's list holds a reference to every subscriber, so a short-lived object that subscribes to a long-lived publisher can't be freed, and its handler keeps running. Whoever subscribes must unsubscribe, usually in . The full memory story is on the card.
One handler throws and the rest don't run, because they run one after another in the same call. And an handler can't be awaited, so its exception can crash the process. Keep handlers small and catch inside them.
With a multicast , only the last method's return value comes back. If you need every answer, loop over .

How I choose in a real app

Inside one process and one object lifetime, an event is fine. In an ASP.NET Core API, where objects live per request, I'd rather inject a list of handlers through DI, for example , because DI controls their lifetime and nothing has to unsubscribe.
Across services, or when the reaction must survive a crash, it's a message on Azure , not a C# event. A C# event lives in memory; if the process restarts, it's gone.

All in one flow

Coming Not written yet: the card pass adds it.

The story

Before
At BMW FS a contract goes live in the nightly . When it does, the customer gets a welcome pack and the ledger gets a posting. The first version of called and directly, by name.
Why it had to change
Then UDC Finance asked for an SMS on activation. To add it, someone had to open the activation code, add a third call, retest activation for all three clients and redeploy it. The class that makes a contract live was changing for a reason that has nothing to do with going live.
How it works now
The activator now owns an event, . An event holds a list of delegates; a delegate is one method plus the object to run it on. The mailer, the ledger and the SMS sender each add themselves with +=. When a contract goes live, the activator raises the event once and every method in the list runs, in order. The diagram above walks it.
What happens next
Adding the SMS was one new class and one += line in Program.cs. didn't change, so it didn't need retesting. Removing a reaction is one -=.
What we gained
The publisher knows nothing about its subscribers. Each reaction is its own small class with its own test. The price: someone must remember to unsubscribe, which is exactly the bug in the try-first exercise below.

In the lending API

The publisher: it owns the event and raises it. It never names who listens.

Only the key lines are shown; Deep walks the whole file.

Lending.sln · where this file sits

src/Domain/Contracts/

⋯ 8 lines in Deep

ContractActivator.cs · line 3 · 1 of 3: outside code may only += and -=. It can't set the list to null or raise it.

The code, file by file

Contract activation in the lending API's nightly . Tap Next to walk the diagram with the code.

Lending.sln · where these 5 files sit

src/
- Worker/
  - Notifications/
- Domain/Contracts/
- Application/Billing/

Diagram · step 1Before: activation calls the mailer and the ledger itself, by name.

ContractActivatorcalls each one by name

MailerWelcomeMailer: welcome pack

LedgerLedgerPoster: posting

Program.cs · line 1 · 1 of 3The publisher. In the real DI builds these as singletons; plain here so you can trace where each object comes from.

What they ask next

The follow-ups interviews really ask. Answer out loud, then tap to check.

ReportedWhat is the difference between a delegate and an event?
An event is a delegate with a lock on it. With a public delegate field, outside code can overwrite it with =, set it to null, or call it. With , outside code can only += and -=; only the class that declares it can raise it. Use a delegate to pass a method in; use an event to let others listen.
```
// delegate field: anyone can do this
activator.OnActivated = null;
activator.OnActivated(this, args);
 
// event: only these compile outside
activator.Activated += Handler;
activator.Activated -= Handler;
```
Where this was reported
ReportedFunc, Action and Predicate: what is the difference?
All three are built-in generic delegate types. returns a value: its last type parameter is the return type, so takes a decimal and returns one. returns nothing. takes one value and returns bool; it's older, and LINQ uses instead.
```
Func<decimal, decimal> addFee =
  amount => amount + 60m;
Action<string> log =
  text => Console.WriteLine(text);
Predicate<int> isLate =
  days => days > 30;
```
Infosys: what is a function delegate?

Follow-up tree

Answer, then open the next level. That is the order an interviewer digs in.

Reporteda candidate was asked Intervieweran interviewer asks it

ReportedWhat is the difference between a delegate and an event?
An event is a delegate with a lock on it. With a public delegate field, outside code can overwrite it with =, set it to null, or call it. With , outside code can only += and -=; only the class that declares it can raise it. Use a delegate to pass a method in; use an event to let others listen.
```
// delegate field: anyone can do this
activator.OnActivated = null;
activator.OnActivated(this, args);
 
// event: only these compile outside
activator.Activated += Handler;
activator.Activated -= Handler;
```
Where this was reported
- Explain this lineWhy do we write ?.Invoke instead of calling it?
  An event with no subscribers is null, so calling it directly throws . ?.Invoke reads the event once and calls it only if it isn't null. Reading it once also matters with threads: another thread could unsubscribe the last handler between a separate null check and the call.
ReportedFunc, Action and Predicate: what is the difference?
All three are built-in generic delegate types. returns a value: its last type parameter is the return type, so takes a decimal and returns one. returns nothing. takes one value and returns bool; it's older, and LINQ uses instead.
```
Func<decimal, decimal> addFee =
  amount => amount + 60m;
Action<string> log =
  text => Console.WriteLine(text);
Predicate<int> isLate =
  days => days > 30;
```
Infosys: what is a function delegate?
- Then why would anyone declare their own type?
  A named type documents intent and can name its parameters, so delegate decimal FeeRule(decimal amount) reads better than a bare . Framework types do it: in ASP.NET Core middleware is a custom delegate. In application code I use and unless the name really helps.
ReportedWhat is the difference between generics and delegates?
They solve different problems. Generics let one class or method work with many types: . Delegates let you pass a method around as a value. They meet in : a delegate type that is also generic, so one type covers every method shape.
Where this was reported
InterviewerWhat is a multicast delegate? What if two methods return values?
Every delegate can hold several methods; += adds one. Calling it runs them all, in the order added. With a , you get only the last method's result; the others are thrown away. If one method throws, the rest don't run. To get every result, or to keep going after a failure, loop over .
```
Func<int> f = () => 1;
f += () => 2;
Console.WriteLine(f()); // 2
```
Microsoft Learn; a common predict-the-output question
InterviewerCan an event handler be async?
It can be , because the handler shape returns void. But nobody can await it: gets control back as soon as the handler hits an that isn't already finished, and the rest runs later. An exception thrown after that point has no caller to catch it; in a or console app (no synchronization context) it crashes the process. So I keep a try-catch inside every async handler, or I don't use an event for async work and await a list of handlers instead. More on the .
Microsoft Learn: async void is for event handlers only
Delegate or interface: when do you pick which?
One method, used once, often as a lambda: a delegate (). Several related methods, or something with its own state and dependencies that DI should build: an . A late-fee rule that needs a database lookup is an interface; a filter in a query is a .

Production bugs, and how to tell them

Each one: what you see, why, the fix in code, and the line to say.

Try first: why does night 3 send three receipts?
```
Navistar Financial customer email, third night of the new payment worker:
"I made ONE payment yesterday and got 3 receipts."
No exception. Worker memory a little higher every night.

Read the Before code and find the bug before you open the cause.
```
Cause
lives for the whole life of the . Each night the job creates a new , and its constructor does +=, but nothing ever does -=. So night 1's sender is still in the event's list on night 2, and night 3 has three. Each one sends a receipt, and none can be freed, because the event holds a reference to each.
Fix
The sender implements and removes itself with -= in ; the job creates it with using, so runs at the end of each night even if the run throws. Better still: subscribe once at start-up, not per run. A test posts on three nights and expects three receipts in total, not six.
Diagram · step 1Night 1: a new sender subscribes with +=. One payment, one receipt.
PaymentPosterlives all week
Postedinvocation list
sender, night 1
Receipt for P-1
Before · ReceiptSender.cs · line 3 · 1 of 3The nightly job calls new ReceiptSender(poster) once per night. The poster is the same object every night.
Say it
Event subscriptions are references. The long-lived poster held every nightly receipt sender ever created, so each payment fired once per old sender. We made the sender disposable, unsubscribed in Dispose with a using block, and added a test that runs three nights. It's the same root cause as an event memory leak; here we saw it as duplicate receipts first.

Production incident

Not on this card A basic concept card: its production story is the try-first bug here and the event leak on the GC and memory card.

Traps

Don't say~~An event is just a delegate.~~SayAn event wraps a delegate so outside code can only subscribe and unsubscribe; only the owner raises it.
Don't say~~Events run in the background.~~SayHandlers run one after another on the thread that raised the event. A slow handler slows the raiser.
Don't say~~The GC cleans up subscribers when they're no longer used.~~SayThe publisher's list holds a reference to every subscriber. Until it unsubscribes, it stays alive and keeps getting called.
Don't say~~-= with the same lambda unsubscribes it.~~Say(s, e) => ... written twice makes two different delegates, so -= with the second finds nothing to remove. Keep the delegate in a variable, or subscribe a named method.

Traps

What should you say instead? Tap to check.

Don't sayAn event is just a delegate.
Say instead
An event wraps a delegate so outside code can only subscribe and unsubscribe; only the owner raises it.
Don't sayEvents run in the background.
Say instead
Handlers run one after another on the thread that raised the event. A slow handler slows the raiser.
Don't sayThe GC cleans up subscribers when they're no longer used.
Say instead
The publisher's list holds a reference to every subscriber. Until it unsubscribes, it stays alive and keeps getting called.
Don't say-= with the same lambda unsubscribes it.
Say instead
(s, e) => ... written twice makes two different delegates, so -= with the second finds nothing to remove. Keep the delegate in a variable, or subscribe a named method.

Live coding

Easy first, then harder. Set a timer and type it before you look.

Task 1

Reportedeasy · 15 minutes

Write code that shows delegates and events: a publisher with an event, two subscribers, and one subscriber leaving. Use a somewhere for a calculation.

Global Quest Solutions: write code demonstrating events and delegates

Stuck? Hints

Declare the event with and raise it with ?.Invoke(this, args).
Subscribe a named method, not a lambda, so you can unsubscribe it.
Where does a fit? A fee rule passed into a method.

Show a solution

Lending.sln · where this file sits

Program.cs · line 7 · 1 of 4A for a real calculation: monthly amount plus a service fee.

What the interviewer checks

keyword, not a public delegate field, and you can say why.
Raised with ?.Invoke, so no subscribers is not a crash.
Event data in a class with read-only properties.
-= used, and the output proves the removed subscriber no longer runs.
A used for a real calculation, not just declared.
Senior extra: says where it would be , and when it would be a queue instead.

With AI tools

Copilot writes delegates well, but two of its habits show up in review. It subscribes with a lambda (x.Changed += (s, e) => ...) and never unsubscribes, and it sometimes "fixes" an unsubscribe by writing -= with a second, identical lambda, which removes nothing. When I review AI code with events I check three things: every += has a matching -= or a reason it lives forever, handlers are named methods, and no handler is missing its try-catch.

Glossary: every name, one line each →

My notes

Paste the NOTES block from your doubt chat here. The grader never reads notes; the coach reads "Still unclear".

Delegates (Microsoft Learn)Events (Microsoft Learn)Distinguishing delegates and events Multicast delegates

Where it was asked

Infosys (.NET developer, 2026)Infosys: what is a delegate and how do you use it?Infosys: generics vs delegates Inceptive: delegates in C# with code Mindfire: what are delegates?r/dotnet: basics still asked (2026)