C# Interview Questions

The runtime only runs .NET applications that are already built. The SDK (Software Development Kit) contains the runtime plus the compiler and the dotnet command-line tools to create, build, test, and publish applications. Developers install the SDK; servers that only run the app need just the runtime.

LTS (Long Term Support) releases, such as .NET 10, get fixes and security patches for 3 years. STS (Standard Term Support) releases get them for 2 years. For a production system that must run for years, like a school system, choose LTS and plan upgrades from one LTS to the next.

The Common Language Runtime is the part of .NET that runs your compiled code. It loads the IL, turns it into machine code with the JIT compiler, manages memory with the garbage collector, and handles exceptions.

IL (Intermediate Language) is what the C# compiler produces: a platform-neutral set of instructions stored in the .dll file. The CLR turns it into machine code when the program runs.

.NET Framework is the original, Windows-only platform; version 4.8.1 is the last, and it only gets maintenance. .NET (Core, then .NET 5 and later) is cross-platform, faster, and where all new development happens.

Just-In-Time compilation turns IL into machine code the first time each method runs, on the machine that runs it. The same .dll can therefore run on Windows, Linux, and macOS, and the JIT can optimize for the exact processor.

Code written directly in Program.cs without a class or Main method. The compiler generates the Main method for you. Only one file in a project can have them, and they are ideal for small programs and for the startup code of ASP.NET Core apps.

In bin/Debug/net10.0: the .dll with your IL, an .exe launcher on Windows, a .pdb with debug information, runtimeconfig.json naming the .NET version to use, and deps.json listing dependencies. They are rebuilt every time and never committed.

Read the app's runtimeconfig.json to see which framework and version it needs, then run dotnet --list-runtimes on the server. If the matching runtime is missing, install it, or publish the app self-contained so it carries its own runtime.

One solution with projects in src (for example SchoolApp.Api, SchoolApp.Core, SchoolApp.Data) and tests. Core holds models and rules with no dependencies, Data references Core, and the API references both. Tests reference what they test.

Framework-dependent apps are small and use the runtime installed on the server, which the operations team patches. Self-contained apps carry their own runtime: larger, but independent of the server, and you must ship updates for security fixes yourself. Containers make this choice simpler, because the image includes the runtime.

int, long, decimal, string, DateOnly, and bool. Matching the types avoids conversion errors and silently wrong values when data moves between the database and C#.

It lets the compiler work out the variable's type from the value on the right, for example var tuition = 42000.00m; is a decimal. The type is still fixed at compile time; var only saves typing, so use it when the type is obvious.

int.Parse converts text to a number and throws an exception if it cannot. int.TryParse returns true or false and gives the number through an out parameter, so bad input never crashes the program. Use TryParse for anything a person types.

double stores numbers in binary, so most decimal fractions are approximations: 0.1 + 0.2 gives 0.30000000000000004. decimal stores base-10 numbers exactly, so sums of fees and payments are exact. double is for measurements where tiny errors do not matter.

An implicit conversion is always safe and needs no code, such as int to long. An explicit cast may lose data, so you must write it, such as (int)92.75m, which gives 92 because the fraction is cut off, not rounded.

A value type variable holds the value itself (numbers, bool, char, DateOnly, structs). A reference type variable holds a reference to an object stored elsewhere (string, classes, arrays), and can be null. Copying a value type copies the value; copying a reference copies only the reference.

The types used for money. If payments are summed in double, the balance can be a tiny non-zero number such as 0.00000000003, so the status check never sees zero. Change money variables to decimal, then correct the stuck invoices with a one-off script.

By default it wraps around silently: a byte at 255 plus 1 becomes 0. Choose types large enough for the data, such as long for Ids that can grow, and use a checked block or the project's overflow-checking setting where a wrong value would be dangerous, so overflow throws an exception instead.

Document one type mapping (for example DECIMAL to decimal, DATE to DateOnly), generate or scaffold entity classes from the database where possible, and check mismatches in code review and integration tests that round-trip real data.

= assigns a value to a variable; == compares two values and returns true or false. Writing if (mark = 33) does not compile in C#: error CS0029, because an int is not a bool.

for repeats a known number of times with a counter; while repeats while a condition is true and may run zero times; foreach visits each item in a collection; do...while runs at least once and then checks its condition.

break leaves the loop immediately. continue skips the rest of the current round and starts the next one. In a switch statement, break ends each case.

A switch statement runs a block of code per case, with case, break, and default. A switch expression produces a value from arms like >= 91 => "A1", checked from top to bottom, with _ for anything else. Switch expressions are shorter for mapping one value to another.

The compiler warns with CS8509 that the switch is not exhaustive, and at run time an unmatched value throws SwitchExpressionException. Always end with a _ discard arm.

condition ? a : b returns a when the condition is true, otherwise b, as a one-line if. Avoid it when the condition or values are complex, or when nested ternaries make the code hard to read; use if or a switch expression instead.

It is a boundary error: the condition uses > where the rule says "33 or more", so it should be >=. Fix the operator, use a named constant such as PassMark, and add tests at the exact boundaries (32, 33, 34) for every rule.

When input comes from a file or a job, it can end; Console.ReadLine then returns null every time, so a validation loop never gets valid input. Check for null and break, and design batch tools to read arguments or files instead of prompting.

Keep each rule in one authoritative place where possible, for example in a shared C# library used by every application, or in the database when reports depend on it. If a rule must exist twice, document it, test both against the same boundary cases, and change them together.

A fixed-size collection of items of one type, stored under one name. Positions (indexes) start at 0, so the last item is at Length - 1, also written ^1.

The program throws IndexOutOfRangeException: Index was outside the bounds of the array. For a six-item array, valid positions are 0 to 5.

$"..." inserts values into text inside braces, such as $"Topper: {name}". Format specifiers control the output: {average:F2} for two decimals, {serial:D5} for zero padding, {name,-8} for column width.

A string can never change after it is created. Methods such as Trim and ToUpper return a new string, so name.Trim(); without assigning the result does nothing. Immutability makes strings safe to share between threads and use as dictionary keys.

When building text in a loop. Each += copies all the text so far into a new string, so the cost grows with every line; StringBuilder appends to one buffer. In the SMS, 10,000 CSV lines took about 620 ms with += and 2 ms with StringBuilder.

string.Equals(a, b, StringComparison.OrdinalIgnoreCase), or methods like Contains and StartsWith with a StringComparison argument. Avoid a.ToUpper() == b.ToUpper(), which creates extra strings and can behave differently across cultures.

How the file text is built. Building it with += in a loop has a cost that grows with the square of the size, so small schools are fine and big ones time out. Switch to StringBuilder or write lines straight to a stream, then measure with production-sized data.

Two arrays kept in step, such as names and marks, break when one is sorted, filtered, or resized without the other, so values attach to the wrong student. Keep related values together in one object, such as a Student class or record, in one collection.

Ordinal, case-insensitive comparison for codes, user names, and emails; culture-aware formatting only for text shown to people; a fixed format such as yyyy-MM-dd for files and APIs; Unicode everywhere (NVARCHAR, UTF-8); and StringBuilder or streaming for large output.

A parameter is the named input in the method's definition, such as decimal maxMarks. An argument is the actual value passed in a call, such as 50m.

A parameter with a default value, such as decimal maxMarks = 100m. Callers can leave it out, and the default is used. Optional parameters must come after the required ones.

Several methods with the same name but different parameter lists, such as CalculateAttendancePercentage(int, int) and CalculateAttendancePercentage(string). The compiler picks one from the argument types. A different return type alone is not enough.

Both pass the caller's own variable. With ref, the variable must be assigned before the call, and the method may read and change it. With out, it need not be assigned before, and the method must assign it before returning. Both keywords appear in the definition and the call.

A method named TryX that returns true or false for success and hands back the result through an out parameter, like int.TryParse. It handles expected failures, such as bad input, without exceptions.

It lets callers pass any number of arguments, which C# collects into an array (or another collection type), such as Average(92m, 85m, 67m). It must be the last parameter.

Too many parameters usually mean the method does too much or the values belong together. Split it into smaller methods, or group related values into an object, such as a request class with properties. Named arguments help readability in the meantime.

Move the calculation into one well-named method with tests at its boundaries, and make every screen call it. Remove the copies. In reviews, treat duplicated business logic as a defect.

Use the Try pattern when failure is expected in normal use, such as parsing what a user typed. Throw an exception when failure means something is truly wrong, such as a missing database record that must exist. Many APIs offer both, like int.Parse and int.TryParse.

A value type with ?, such as int? or decimal?, that can hold either a value or null. It has HasValue and Value. It maps to SQL columns that allow NULL, such as a mark for an absent student.

?? returns the left value unless it is null, then the right value, like SQL's COALESCE. ?. accesses a member only if the object is not null, and returns null otherwise, instead of throwing NullReferenceException.

Using a member, such as .Length or a method, on a variable that holds null. The message is "Object reference not set to an instance of an object." Check for null first, or use ?. and ??.

A compiler feature, turned on with <Nullable>enable</Nullable>, where string means "never null" and string? means "may be null". The compiler warns (CS8600, CS8602, and others) when code might use a null unsafely. It changes warnings, not run-time behavior.

x! tells the compiler to treat x as not null and silences the warning. It does nothing at run time, so if x is null the program still crashes. Use it only when you truly know better than the compiler, with a comment.

Skip them: add only marks that are not null and divide by how many were counted, as SQL's AVG does. Treating an absent student's null as 0 lowers the average unfairly: 395 ÷ 5 is 79, but 395 ÷ 6 is 65.83.

Read the stack trace for the exact line, then find which value is null and why, for example a guardian with no email. Fix it where the value is used, with a null check and a sensible fallback, and make the type string? so the compiler warns at every other use.

Enable it project by project or file by file (#nullable enable), starting with shared core code. Fix warnings in small batches, annotate public APIs first, and turn warnings into errors once a project is clean, so it stays clean.

Decide per field: NULL-able columns map to ? types in C#, and the API either returns null in JSON or omits the field, documented in the API contract. Never turn missing data into fake values such as 0 or empty strings, which clients cannot tell apart from real data.

try holds code that might fail. catch runs when a matching exception is thrown in try. finally always runs afterwards, success or failure, so it is used for cleanup.

It travels up through every calling method. If none catches it, the program stops and prints "Unhandled exception" with the exception type, message, and stack trace.

A breakpoint (F9) pauses the program at a line so you can inspect variables. F10 steps over the current line; F11 steps into the method called on that line. The Locals and Call Stack windows show the values and the chain of calls.

throw; rethrows the current exception and keeps its original stack trace. throw ex; restarts the stack trace from the rethrow, so the place where the error really happened is lost. The analyzer warns with CA2200. Always use throw;.

C# uses the first catch block whose type matches. If catch (Exception) comes first, it matches everything, and later specific blocks never run. Put the most specific types first.

Return a result for expected situations, such as invalid user input, using the Try pattern. Throw when a rule is broken in a way the method cannot handle, such as a mark above the maximum reaching the save method. Exceptions are for exceptional cases, not normal flow.

A swallowed exception: an empty catch or one that logs nothing. Search for empty catch blocks around the save path, use the debugger's Exception Settings to stop where exceptions are thrown, and check database logs. Remove the empty catch so the real error appears, then fix the cause.

Read the exception type and message first, then the at lines from the top, skipping framework methods (System.) until you reach your own code. The first line in your code with a file and line number is usually where to start; the lines below show who called it.

Validate input early and return clear validation results. Let lower layers throw specific exceptions for broken rules, and do not catch what you cannot handle. Handle everything once, at the edge: global middleware logs the full exception with a correlation id and returns a safe, consistent error response, without exposing internal details.