.NETOOP and C# basicsReported by candidates

What are static, sealed and partial classes, and when do you use each?

Asked in first technical rounds at Infosys, EbixCash (twice), HCLTech, Accenture and six other companies; latest report September 2026.

Say this first · about 30 seconds

A static class can't be created with new and holds only static members: one copy for the whole app. I use it for stateless helpers, constants and extension methods, never for data that changes per request, because every request shares it.
A sealed class can't be inherited. I seal by default, so nobody overrides behaviour that wasn't designed for it.
A partial class is one class split across files that the compiler joins at build time. It's for generated code: EF Core scaffolding writes one file, and I write mine in another, so regenerating never wipes my code.

Make it yours · UDC Finance GST helper (invented example)

Situation: at UDC Finance every quote adds New Zealand , a 15% tax. Three services each had their own copy of the maths, and one stored the last quote in a static field "for logging".
What I did: one static class, , with the rate as a constant and one method, . It keeps no data that changes. In review I removed the static field: it was shared by every request.
Result: one place for the tax rule, nothing to create or inject, and no shared state. If the rate ever came from config, I'd make it a normal class in DI.
What I'd say: static is right for pure functions and constants; wrong for anything that holds per-request data.

The code, simplified

Invented to show the shape, in C#. Tap Next to walk a 1,000 quote through .

UDC.sln · where these 2 files sit

Quotes/
Common/

Diagram · step 1The quote calls on the class itself. No object is created.

QuoteService

Gststatic class

Add(1000)

QuoteService.cs · line 1 · 1 of 2Inside , called by the quote controller for one UDC customer.

Fix later in your repo The rate is a constant; if NZ changes , it would move to config and a DI service.

Say it out loud, then check

Show the 30-second answer

A static class can't be created with new and holds only static members: one copy for the whole app. I use it for stateless helpers, constants and extension methods, never for data that changes per request, because every request shares it.
A sealed class can't be inherited. I seal by default, so nobody overrides behaviour that wasn't designed for it.
A partial class is one class split across files that the compiler joins at build time. It's for generated code: EF Core scaffolding writes one file, and I write mine in another, so regenerating never wipes my code.

Check your answer: tick what you said

Static class: no instances, only static members, one copy per app. For stateless helpers, constants, extension methods.
Static members are shared by every request and thread: a mutable static field is a race. Request data belongs in local variables or scoped services.
A static class is sealed and abstract under the hood: it can't be inherited, can't implement an interface, can't be injected or faked in a test.
Sealed class: can't be a base class. Seal what wasn't designed for inheritance; .NET can also skip the virtual call lookup. string is sealed.
Partial class: one class in several files, merged at compile time; same assembly, same namespace, all parts marked partial.
Main use of partial: generated code (EF Core scaffolding, WinForms designer, source generators) next to hand-written code.
Partial methods let generated code declare a hook that your half may implement.

You said 0 of 7

Then add your example: UDC Finance GST helper (invented example)

Situation: at UDC Finance every quote adds New Zealand , a 15% tax. Three services each had their own copy of the maths, and one stored the last quote in a static field "for logging".
What I did: one static class, , with the rate as a constant and one method, . It keeps no data that changes. In review I removed the static field: it was shared by every request.
Result: one place for the tax rule, nothing to create or inject, and no shared state. If the rate ever came from config, I'd make it a normal class in DI.
What I'd say: static is right for pure functions and constants; wrong for anything that holds per-request data.

See it

Contract.cswritten by EF Core

PropertiesId, Balance, DaysOverdue

IsInArrears()added by hand

1/6Before: EF Core wrote from the database. A developer added a method inside that file.

In plain words

Words used below. A request is one call to our web API, for example one customer asking for a quote; many run at the same time. EF Core is the .NET library that maps C# classes to database tables, and to scaffold means EF Core reads the database and writes those C# classes for you. Generated code is code a tool writes; you don't edit it by hand, because the tool overwrites it. DI (dependency injection) is ASP.NET Core building your service objects for you; a singleton is one object it shares with everyone.
A static class is a wall clock in an office. Nobody gets their own copy; everyone reads the same one. That's perfect for something that never changes per person, like the time or a tax rate. It's a disaster if someone writes their own notes on it: the next person reads them as theirs.
A sealed class is a sealed product box: you can use what's inside, but you can't open it up and build your own version on top of it.
A partial class is one document with two authors in separate files. A machine writes one file and rewrites it whenever it likes; you write the other. When the code is built, the two files become one class.

The senior answer · about 2 minutes

Static

A static class is for code that needs no object and keeps no data that changes: rounding money, a tax rate constant, extension methods, which add a method to an existing type without changing it, like services.AddLending() that registers all our services in one call. The compiler won't let you write on it, and every member must be static. The walks the difference between static and instance members.
The danger isn't the class, it's a static field that changes. There is one copy for the whole process, so every request and every thread shares it. If two requests write it at the same time, one overwrites the other. That's the try-first bug below.
Static also means hard to replace. A static class can't implement an interface or be injected, so a test can't swap it for a fake. If it talks to a database, the clock or an HTTP API, I make it a normal class registered in DI instead, often as a singleton.

Sealed

A sealed class can't be a base class; trying gives a compile error. I seal by default, because a class that allows inheritance must be designed for it: which methods are safe to override and in what order they run. Unsealing later is easy; sealing later breaks anyone who inherited.
There's a small speed gain too: when you call a virtual or interface method through a sealed type, .NET knows no override can exist and can call it directly instead of looking it up. string is sealed for both reasons: nobody can change how a string behaves. The has the details, including sealing one override.

Partial

A partial class is one class written in several files. Every part says partial, they must be in the same project and namespace, and the compiler merges them into one class before anything runs. At run time there's no trace of the split.
I use it where a tool owns one half. EF Core's scaffold command generates entity classes from the database and overwrites them every time we rerun it. Our own methods go in a second file with the same partial class, so a regenerate never deletes them. Source generators, like the logging and regex ones in .NET, use the same trick.
I don't use partial to split a big hand-written class into files. A class that big has too many jobs; splitting the file hides that instead of fixing it.

All in one flow

Coming Not written yet: the card pass adds it.

The story

Before
UDC Finance's lending API gets its entity classes from EF Core's scaffold command: it reads the tables and writes one C# class per table. A developer needed an "is this contract in arrears?" check and added straight into the generated .
Why it had to change
Weeks later a added a column for the fee. Someone reran scaffold with --force, which rewrites every generated file. vanished, and the build broke in every place that called it. Worse when it doesn't break: a changed rule inside the file is silently reset.
How it works now
EF Core marks every class it writes as partial. So our method moves to a second file, , that also says partial class Contract. Scaffold only rewrites its own file. When the project builds, the compiler merges both parts into one class, so the rest of the code never knows there are two files. The diagram walks it.
What happens next
The now uses all three kinds. is partial. is sealed, so nobody subclasses it to change how a is calculated. is a static class: a rounding helper that keeps no data, called without creating anything.
What we gained
Regenerating is safe. Behaviour can't be changed by a surprise subclass. And the only static code is code with nothing to share. The one rule that needs care is static fields, which is the try-first bug below.

In the lending API

Our half of the entity. EF Core's half is in the next file; the compiler joins them.

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

Lending.sln · where this file sits

src/Infrastructure/Data/Entities/

⋯ 1 line in Deep⋯ 1 line in Deep

Contract.Custom.cs · line 2 · 1 of 2Same name, same namespace, same project, and partial on every part. Leave it off one part and the build fails (CS0260, missing partial modifier).

The code, file by file

A UDC Finance in the lending API: an EF Core entity in two parts, a static helper and a sealed service. Tap Next to walk the diagram with the code.

Lending.sln · where these 4 files sit

src/
- Infrastructure/Data/Entities/
- Application/
  - Quotes/
  - Common/

Diagram · step 1Before: EF Core wrote from the database. A developer added a method inside that file.

Contract.cswritten by EF Core

PropertiesId, Balance, DaysOverdue

IsInArrears()added by hand

Contract.cs · line 1 · 1 of 3This comment tells people, and tools, that a generator owns this file. Edits here are lost on the next scaffold.

What they ask next

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

ReportedWhat is a partial method?
A method whose signature is written in one part of a partial class and whose body may be written in another. Generated code uses it to offer a hook: EF Core's generated context declares , and your own file can fill it in to add database settings. In the classic form it returns nothing and is private; if nobody writes the body, the compiler simply deletes the call. Since C# 9 it may be public or return a value, but then a body is required.
```
// generated half
partial void OnModelCreatingPartial(
  ModelBuilder modelBuilder);
 
// our half (optional)
partial void OnModelCreatingPartial(
  ModelBuilder modelBuilder)
{
  // extra config
}
```
MPRDC: what is the partial?

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

Should every class be sealed by default? What does it cost you?
For application code, yes: seal unless the class was designed to be a base class. The cost shows up in tests: a mocking library like Moq fakes a class by inheriting from it, so it can't fake a sealed class. The answer is to depend on an interface and fake that, which is better design anyway. Speed gains are small and only for virtual or interface calls, where .NET can skip the lookup. Library authors are more careful: sealing a public class later breaks users who inherited it.
- Can you seal a single method instead of the class?
  Yes, but only an override: public sealed override decimal AmountDue(). It stops classes further down from overriding it again. A method that isn't virtual can't be overridden anyway, so alone on it means nothing.
ReportedWhat is a partial method?
A method whose signature is written in one part of a partial class and whose body may be written in another. Generated code uses it to offer a hook: EF Core's generated context declares , and your own file can fill it in to add database settings. In the classic form it returns nothing and is private; if nobody writes the body, the compiler simply deletes the call. Since C# 9 it may be public or return a value, but then a body is required.
```
// generated half
partial void OnModelCreatingPartial(
  ModelBuilder modelBuilder);
 
// our half (optional)
partial void OnModelCreatingPartial(
  ModelBuilder modelBuilder)
{
  // extra config
}
```
MPRDC: what is the partial?
ReportedWhat are the different types of classes in C#?
By what they allow: a normal (concrete) class you can create and inherit; an class you can only inherit; a sealed class you can only create; a static class you can do neither with. Partial isn't a kind of class, it's how the source is split. Then generic classes (), nested classes, and records, which are classes with value-based equality.
Where this was reported
ReportedCan an interface have static members? Can a class implement a static interface?
There's no such thing as a static interface; that doesn't compile. But an interface can have static members: since C# 8, static methods with a body, and since C# 11, static abstract members that every implementing class must provide. That's what generic maths in .NET 7 uses: lets one method add ints or decimals. And a static class can't implement any interface, because there is no object to treat as one.
```
public interface IRateSource
{
  static abstract string Name { get; }
}
public sealed class UdcRates : IRateSource
{
  public static string Name => "UDC";
}
```
Reported wording: can we use a static interface in a public class?
InterviewerWhen does a static constructor run, and what if it throws?
Once per process, before the class is first used, and the runtime makes it thread-safe: two threads can't both run it. If it throws, every use of that class for the rest of the process throws ; it never retries. So I never read config or call a database from a static constructor: one bad setting at start-up and the class is dead until a restart.
Microsoft Learn: static constructors
Static class or singleton?
Answered on the : a singleton is an object, so it can implement an interface, be injected and be faked in tests. In ASP.NET Core I register a singleton in DI rather than writing a static class whenever the code has dependencies.

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 did a customer see another customer's payoff?
```
UDC Finance support ticket, Monday 10:05:
"My payoff quote says $8,350. I owe over $12,000."
Only at busy times. Never in tests. No exception.

Read the Before code and find the bug before you open the cause.
```
Cause
_total is a field, so there is one copy for the whole API, shared by every request. means "wait for this database call without blocking": while request A waits, the server runs other requests. Request A stores its balance, 12,000, then waits for the fee lookup. While it waits, request B stores 8,000 in the same field and adds its fee of 100. When A resumes, it reads the field again, now B's 8,100, adds its own 250 fee and returns 8,350. Tests send one request at a time, so they never see it. The covers how requests run at once.
Fix
Make total a local variable. Each call gets its own copy on its own stack, so nothing is shared. Don't reach for first: the data was never meant to be shared, so remove the sharing. A test runs two quotes at the same time and checks each gets its own amount.
Diagram · step 1A sets _total to its balance, 12,000, then awaits the fee lookup.
one static decimal _total for the whole API
Request A
Request B
_total
await fee
12,000
7 ms
Before · PayoffService.cs · line 3 · 1 of 4One copy for the whole API, shared by every request at once.
Say it
A static field is one copy per process, not per request. The service kept a running total in a static field across an await, so a second request overwrote it mid-calculation and a customer saw a blend of two quotes. The fix wasn't a lock; it was a local variable, because request data should never be shared. We added a test that runs two quotes in parallel, and a review rule: no mutable static fields.

Production incident

Not on this card A basic concept card: its production story is the try-first static-field race here; thread races in depth are on the Task vs Thread card.

Traps

Don't say~~Partial classes are for splitting a big class into smaller files.~~SayPartial is for generated code next to hand-written code. A class too big for one file has too many jobs; split the class, not the file.
Don't say~~A sealed class is immutable.~~SaySealed only stops inheritance. Its fields can still change; immutability is read-only fields and no setters.
Don't say~~Fix a shared static field with a lock.~~SayFirst ask why request data is static at all. A local variable or a scoped service removes the sharing; a lock just makes requests wait for each other.
Don't say~~Parts of a partial class can live in different projects.~~SayAll parts must be in the same project (assembly) and namespace; the compiler merges them in one build.

Traps

What should you say instead? Tap to check.

Don't sayPartial classes are for splitting a big class into smaller files.
Say instead
Partial is for generated code next to hand-written code. A class too big for one file has too many jobs; split the class, not the file.
Don't sayA sealed class is immutable.
Say instead
Sealed only stops inheritance. Its fields can still change; immutability is read-only fields and no setters.
Don't sayFix a shared static field with a lock.
Say instead
First ask why request data is static at all. A local variable or a scoped service removes the sharing; a lock just makes requests wait for each other.
Don't sayParts of a partial class can live in different projects.
Say instead
All parts must be in the same project (assembly) and namespace; the compiler merges them in one build.

Live coding

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

Task 1

Reportedeasy · 10 minutes

Write a thread-safe singleton in C#: one object for the whole app, created only when first used. Then say when you'd use a DI singleton instead.

Publicis Sapient, tech round, April 2026: singleton implementation

Stuck? Hints

How do you stop other code writing new RateTable()? (a private constructor)
is a .NET type that creates its value once, the first time you ask, and is safe when two threads ask together.
Why mark the class ?

Show a solution

Lending.sln · where this file sits

RateTable.cs · line 1 · 1 of 5 says nobody should extend this. The private constructor already blocks outside subclasses; sealing also blocks a nested one.

What the interviewer checks

Private constructor, so fails outside the class.
static readonly Lazy<RateTable>: created on first use, thread-safe by default.
Class is : it states the intent, and closes the last gap, a nested class inheriting it.
No hand-written (the older double-checked locking pattern); does it for you.
Says the DI answer: AddSingleton<IRateTable, RateTable>() gives one instance plus an interface, so tests can fake it.

With AI tools

AI assistants like to make helpers static and to cache things in static fields, because it's short and it compiles. In review I check every field that isn't or const: who writes it, and can two requests write it at once? I also check that nobody, human or AI, edited a file marked <auto-generated/>; that edit is lost on the next scaffold and belongs in the partial file.

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".

Static classes and static members (Microsoft Learn)Abstract and sealed classes (Microsoft Learn)Partial classes and methods (Microsoft Learn)EF Core scaffolding: custom code in partial classes Static constructors (Microsoft Learn)

Where it was asked

Infosys: why do we use sealed classes?EY GDS: what is a partial class?Yovant: what are the different types of classes?IQVIA: can we use a static interface in a public class?MPRDC: what is partial?