Question 1

What is the difference between a value type and a reference type?

Accepted Answer

A value type variable holds the data itself ( int , bool , decimal , DateTime , any struct / enum ). Assigning it copies the value. A reference type variable holds a reference to an object on the managed heap ( class , string , arrays, delegates, record ). Assigning it copies the reference, so two variables can point to the same object. csharp Copy var a = new List int (); var b = a; b.Add( 1 ); // a.Count == 1 — same object int x = 1 ; int y = x; y++; // x is still 1 Value types are stored inline (stack for locals, inside the parent object for fields); reference-type objects always live on the heap and are cleaned up by the GC.

Question 2

What is the difference between string and StringBuilder?

Accepted Answer

In short: string is immutable : every concatenation creates a new string object, so building a string in a loop causes many allocations (O(n²) copying). StringBuilder keeps a mutable buffer and appends in place; call ToString() once at the end. Use StringBuilder for loops or many appends, plain strings/interpolation for a handful of pieces.

Question 3

Explain const vs readonly vs static readonly.

Accepted Answer

const : compile-time constant, implicitly static, only primitives/strings; the value is baked into callers at compile time. readonly : instance field assigned at declaration or in a constructor; can differ per object. static readonly : one value per type, computed at runtime (e.g. static readonly HttpClient Client = new() ). Gotcha: if library A has public const int Max = 10 and app B uses it, changing it to 20 in A does nothing in B until B is recompiled. Use static readonly for values that may change.

Question 4

What are boxing and unboxing? Why avoid them?

Accepted Answer

In short: Boxing converts a value type to object (or an interface) by allocating a heap object and copying the value; unboxing casts it back to the exact value type. It costs an allocation, a copy and GC pressure. Typical sources: non-generic collections ( ArrayList ), string.Format with value-type arguments on old APIs, calling interface methods on structs via the interface. Generics remove most boxing.

Question 5

What is the difference between == and .Equals()?

Accepted Answer

In short: For reference types , == compares references unless the operator is overloaded; Equals() is virtual and can be overridden to compare content. string overloads both to compare text. Records generate value-based Equals and == . For value types, Equals compares content. When you override Equals , also override GetHashCode (objects that are equal must have the same hash code, or dictionaries break).

Question 6

What are ref, out and in parameters?

Accepted Answer

All three pass an argument by reference : ref — must be initialised before the call; the method can read and change it. out — need not be initialised; the method must assign it (used by TryParse ). in — read-only reference; avoids copying large structs.

Question 7

What is the difference between var, dynamic and object?

Accepted Answer

In short: var is compile-time type inference — the variable is strongly typed ( var x = 5 is an int ). object is the base type; you need casts to use members. dynamic skips compile-time checks and resolves members at runtime through the DLR; errors appear as RuntimeBinderException . Use dynamic only for COM interop, dynamic JSON or scripting scenarios.

Question 8

What is the difference between an array, ArrayList and List<T>?

Accepted Answer

In short: An array has a fixed size and a single element type. ArrayList (non-generic, legacy) stores object , so value types get boxed and you need casts. List T is generic, type-safe, resizable (it doubles its internal array when full) and has no boxing. Always prefer List T .

Question 9

Explain IEnumerable, ICollection, IList and IQueryable.

Accepted Answer

IEnumerable T : forward-only iteration ( foreach ), deferred execution with LINQ to Objects, runs in memory . ICollection T : adds Count , Add , Remove , Contains . IList T : adds index access and Insert . IQueryable T : builds an expression tree that a provider (EF Core) translates to SQL and runs in the database . csharp Copy db.Orders.Where(o = o.Total 100 ).ToList(); // IQueryable: WHERE in SQL db.Orders.AsEnumerable().Where(o = o.Total 100 ).ToList(); // loads ALL rows then filters in memory

Question 10

What are delegates and events? How do they differ?

Accepted Answer

In short: A delegate is a type-safe function pointer ( Func , Action , custom delegate ). It can be multicast. An event wraps a delegate so outside code can only += / -= handlers; only the declaring class can raise it. This prevents subscribers from wiping out other handlers ( = null ) or raising the event themselves. Pattern: `public event EventHandler ? Changed; and raise with Changed?.Invoke(this, args)`.

Question 11

How does async/await work internally? Does it create a new thread?

Accepted Answer

In short: No new thread is created by await . The compiler turns the method into a state machine . When it hits await on an incomplete task, the method returns to its caller and the thread goes back to the pool. When the I/O completes, a continuation resumes the state machine — on the captured synchronisation context if there is one (UI thread), otherwise on a thread-pool thread. CPU-bound work still needs Task.Run or parallelism to move off the current thread.

Question 12

What is the difference between Task.WhenAll and awaiting tasks one by one?

Accepted Answer

In short: Awaiting sequentially makes total time the sum of the calls; starting all tasks and then await Task.WhenAll(...) makes it roughly the longest single call. WhenAll throws the first exception when awaited, but the returned task s Exception holds all of them. Use WhenAny for first to finish or timeouts.

Question 13

Why is async void dangerous?

Accepted Answer

In short: Callers can t await it, so they can t know when it finishes, and an exception thrown inside crashes the process (it is raised on the synchronisation context instead of being stored in a Task). Use async Task everywhere except event handlers.

Question 14

What is IDisposable and the using statement? Dispose vs Finalize?

Accepted Answer

In short: IDisposable.Dispose() releases unmanaged resources (connections, file handles) deterministically . using guarantees Dispose is called even if an exception is thrown (compiles to try/finally ). A finaliser is called by the GC at an unpredictable time and costs an extra GC cycle; it is only a safety net for raw unmanaged handles. In Dispose call GC.SuppressFinalize(this) if a finaliser exists. Most code just wraps SafeHandle and never writes a finaliser.

Question 15

Explain garbage collection generations.

Accepted Answer

In short: The heap is split into Gen 0 (new objects, collected very often and cheaply), Gen 1 (survivors of Gen 0, a buffer), and Gen 2 (long-lived objects, collected rarely and expensively). Most objects die young, so collecting Gen 0 frequently is efficient. Objects of 85,000 bytes or more go to the Large Object Heap , collected with Gen 2. .NET has workstation and server GC modes, plus background (concurrent) GC for Gen 2.

Question 16

What are extension methods? Any limitations?

Accepted Answer

In short: Static methods in a static class whose first parameter has this , called as if they were instance methods. LINQ is built on them. Limitations: they can t access private members, an instance method with the same signature always wins, and they re resolved at compile time (no polymorphism). C# 14 adds extension members (properties, static members) via extension blocks.

Question 17

What is the difference between struct and class?

Accepted Answer

In short: Struct: value type, copied on assignment, no inheritance (can implement interfaces), can t have a parameterless constructor before C# 10, ideal for small immutable data. Class: reference type, supports inheritance and polymorphism, lives on the heap, compared by reference by default. Large mutable structs are a common bug source (you modify a copy).

Question 18

What are records and when do you use them?

Accepted Answer

In short: record (C# 9) is a class with value-based equality , a generated ToString , deconstruction and with expressions for non-destructive copies. record struct (C# 10) is the value-type version. Use them for DTOs, messages, events and value objects. Avoid them for EF Core entities that are tracked by identity and mutated.

Question 19

What are generics and what problem do they solve?

Accepted Answer

In short: Generics let you write type-safe code once for many types ( List T , Repository T ). They remove casts and boxing, and errors show up at compile time. Constraints ( where T : class, new() ) restrict which types can be used. For value types the JIT generates specialised code; for reference types the code is shared.

Question 20

What is the difference between throw and throw ex?

Accepted Answer

In short: throw; rethrows the current exception and preserves the original stack trace . throw ex; throws it again from the current line, losing where it really failed. To add context, throw a new exception and pass the original as innerException .

Question 21

Why should you use decimal instead of double for money?

Accepted Answer

In short: double is binary floating point and can t represent many base-10 fractions exactly (0.1 + 0.2 != 0.3), so totals drift by tiny amounts that show up in invoices and reports. decimal stores base-10 digits exactly with 28–29 significant digits. Trade-off: decimal is slower and uses 16 bytes, so use double for scientific/graphics maths and decimal for money and quantities that must add up exactly. In SQL Server map it to DECIMAL(18,2) , not FLOAT .

Question 22

What is the difference between Parse, TryParse and Convert?

Accepted Answer

In short: int.Parse( x ) throws FormatException for bad input (and ArgumentNullException for null). int.TryParse(s, out var n) returns false instead of throwing — use it for user input. Convert.ToInt32(value) accepts many types (object, double, string), returns 0 for null , and rounds doubles to the nearest even number ( Convert.ToInt32(2.5) → 2) whereas a cast truncates ( (int)2.9 → 2). Pass a CultureInfo when parsing numbers and dates from files or APIs.

Question 23

What is the difference between Dictionary and Hashtable?

Accepted Answer

In short: Dictionary TKey,TValue is generic: type-safe, no boxing, faster; a missing key with the indexer throws KeyNotFoundException (use TryGetValue ). Hashtable is the old non-generic version storing object keys/values: needs casts, boxes value types, and returns null for a missing key. Both are hash tables with O(1) average lookup. For multiple threads use ConcurrentDictionary .

Question 24

What is the difference between a multidimensional and a jagged array?

Accepted Answer

In short: A multidimensional (rectangular) array int[,] is one object where every row has the same length, accessed as a[r, c] . A jagged array int[][] is an array of arrays — each row is a separate array and can have a different length, accessed as a[r][c] . Jagged arrays are more flexible and often faster in .NET; rectangular arrays suit fixed grids such as matrices.

Question 25

When do you use for, foreach, while and do-while?

Accepted Answer

In short: for when you need the index or a counted loop; foreach to read every item of any IEnumerable (cleanest, but you can t add/remove items of a List inside it); while to repeat while a condition is true (may run zero times); do-while when the body must run at least once (menus, retry prompts). break exits the loop, continue skips to the next iteration.

Question 26

What is a namespace? Explain the two meanings of using.

Accepted Answer

In short: A namespace groups related types and prevents name clashes ( Shop.Models.Order vs Billing.Order ). The using directive ( using System.Text; ) imports a namespace — plus using static , aliases and global using . The using statement/declaration ( using var conn = new SqlConnection(...) ) calls Dispose() automatically at the end of the scope, even if an exception is thrown.

Question 27

What are anonymous types?

Accepted Answer

In short: Compiler-generated, unnamed classes with read-only properties, created with new { Name = Asha , Age = 28 } and used through var . They have value-based Equals / GetHashCode , and are mostly used for LINQ projections within one method. They can t be returned in a typed way or have methods — use a record or a tuple for that.

Question 28

What is the difference between Stack and Queue?

Accepted Answer

In short: Stack T is LIFO — Push adds to the top, Pop removes the most recent, Peek reads it (undo, expression parsing, DFS). Queue T is FIFO — Enqueue adds at the back, Dequeue removes the oldest (job processing, BFS, buffering). Both are O(1) for add/remove; TryPop / TryDequeue avoid exceptions on empty collections; PriorityQueue T,P dequeues by priority.

Question 29

How do you create a custom exception, and when should you?

Accepted Answer

In short: Derive from Exception , end the name with Exception , provide the standard constructors (parameterless, message, message + inner exception) plus constructors/properties for useful data (e.g. Balance , Requested ). Create one only when callers need to catch that specific situation (e.g. InsufficientFundsException → show a friendly message or return 409); otherwise throw the built-in ones ( ArgumentException , InvalidOperationException ). Always pass the inner exception when wrapping.

Question 30

What is the difference between Tuple and ValueTuple?

Accepted Answer

In short: Tuple T1,... (.NET 4) is a class on the heap with read-only Item1 , Item2 properties. ValueTuple (C# 7, syntax (int Id, string Name) ) is a struct — no allocation — with named, mutable fields, deconstruction ( var (id, name) = ... ) and == support. Use ValueTuple for returning several values from private/internal methods; use a record for public APIs because tuple element names are not kept at runtime.

Question 31

What is the difference between Func, Action and Predicate?

Accepted Answer

In short: All are built-in generic delegate types. Func T1..., TResult takes up to 16 inputs and returns a value ( Func int,int,int add ). Action T1... takes inputs and returns void ( Action string log ). Predicate T takes one input and returns bool , used by List T .Find/FindAll/RemoveAll ; LINQ uses Func T,bool for the same idea.

Question 32

What is a multicast delegate?

Accepted Answer

In short: A delegate whose invocation list contains several methods, built with += and reduced with -= . Invoking it calls each method in order; for delegates with a return value only the last result is returned, and an exception in one handler stops the rest. Events are built on multicast delegates — that s how many subscribers receive one event.

Question 33

How do you read a very large file efficiently in C#?

Accepted Answer

In short: Stream it instead of loading it all: File.ReadLines(path) (lazy IEnumerable string ) or a StreamReader with ReadLineAsync in a loop, a FileStream with a reasonable buffer for binary data, and CopyToAsync to move data between streams. Avoid File.ReadAllText/ReadAllLines for large files (whole file in memory), dispose streams with using , and use async I/O in server apps.

Question 34

DateTime vs DateTimeOffset — which should you store?

Accepted Answer

In short: DateTime holds a date/time with a Kind (Local, Utc, Unspecified) but no offset, so the same value can mean different instants on different servers. DateTimeOffset stores the instant plus the UTC offset, so it is unambiguous. Store UTC ( DateTime.UtcNow or DateTimeOffset ) in databases and APIs, convert to the user s time zone only for display, use DateOnly for pure dates like birthdays, and TimeProvider to make now testable.

Question 35

What is a [Flags] enum?

Accepted Answer

In short: An enum whose values are powers of two ( Read = 1, Write = 2, Delete = 4 ) so several can be combined in one value with bitwise OR ( Read | Write ). Test with (value Flag) != 0 or HasFlag , remove with value = ~Flag . [Flags] also makes ToString() print Read, Write . Typical for permissions and options.

Question 36

How do you make code thread-safe? Compare lock, Monitor, SemaphoreSlim, Interlocked and concurrent collections.

Accepted Answer

lock (sugar for Monitor.Enter/Exit ): mutual exclusion inside one process, synchronous only. SemaphoreSlim : limits concurrency to N and supports WaitAsync , so use it when you must await inside the critical section. Interlocked : atomic operations on single variables (increment, compare-exchange), lock-free. ConcurrentDictionary / ConcurrentQueue / Channel T : built-in thread-safe structures. Immutability: data that never changes needs no locks. Across processes/servers: database locks, distributed locks (Redis, blob leases), Mutex for the same machine.

Question 37

What causes a deadlock with async code and how do you avoid it?

Accepted Answer

In short: Classic case: in a UI app or old ASP.NET (with a synchronisation context), code calls task.Result . The blocked thread holds the context; the awaited method s continuation needs the same context to resume, so both wait forever. Fixes: go async all the way ( await instead of .Result ), use ConfigureAwait(false) in library code, and never mix blocking and async calls. ASP.NET Core has no synchronisation context, but blocking still causes thread-pool starvation under load.

Question 38

What are Span and Memory?

Accepted Answer

In short: Span T is a stack-only ( ref struct ) view over contiguous memory: arrays, stackalloc or native memory. You can slice and parse without allocating new arrays or strings. It can t be a class field, boxed or used across await . Memory T is the heap-storable counterpart, usable in async methods. Both are used heavily inside ASP.NET Core and System.Text.Json for performance.

Question 39

What is the difference between Task and ValueTask?

Accepted Answer

In short: Task is a class, so every async call that returns one allocates (except cached completed tasks). ValueTask T is a struct that avoids the allocation when the result is often available synchronously (e.g. from a cache). Rules: await a ValueTask only once , don t await it concurrently, and convert with .AsTask() if you need to. The default is still Task .

Question 40

What are covariance and contravariance?

Accepted Answer

In short: They allow implicit conversion of generic type arguments. Covariance ( out T ) works for outputs: IEnumerable string → IEnumerable object . Contravariance ( in T ) works for inputs: Action object → Action string , IComparer Animal used as IComparer Dog . Only interfaces and delegates support this, and only for reference types.

Question 41

What are source generators and why are they replacing reflection?

Accepted Answer

In short: Source generators run during compilation and add C# code to the project. They remove runtime reflection costs, work with trimming and Native AOT, and catch errors at build time. Examples: System.Text.Json JsonSerializerContext , [LoggerMessage] , [GeneratedRegex] , [LibraryImport] .

Question 42

A method builds a CSV of 200,000 rows using += on a string and takes minutes. What do you do?

Accepted Answer

In short: String concatenation in a loop copies the whole string every time, so the work is O(n²). Replace it with a StringBuilder , or better, stream the rows straight to the output ( StreamWriter , or PipeWriter in ASP.NET Core) so the full file is never held in memory. Measure before and after with a stopwatch or BenchmarkDotNet. For huge exports, page the database query and write as you read.

Question 43

Your API's memory keeps growing until the pod restarts. How would you investigate?

Accepted Answer

Confirm the trend with dotnet-counters (GC heap size, Gen 2 count, LOH size). Take memory dumps a few minutes apart with dotnet-dump collect (or dotnet-gcdump ) and compare which types grow, using Visual Studio, PerfView or dotnet-dump analyze ( dumpheap -stat , gcroot ). Usual culprits: static collections or caches with no eviction, event handlers never unsubscribed, HttpClient created per request, undisposed streams/DbContexts, large byte arrays on the LOH, unbounded MemoryCache . Fix (size-limited cache, IHttpClientFactory , using , weak events), then load-test to confirm.

Question 44

Two users update the same in-memory counter and some increments are lost. Why, and how do you fix it?

Accepted Answer

In short: count++ is read, add, write — three steps. Two threads can read the same value and both write value+1, so one increment is lost (a race condition). Fix with Interlocked.Increment(ref count) , a lock , or a concurrent type. If the counter must survive restarts or work across several servers, keep it in the database (`UPDATE ... SET Count = Count + 1 ) or in Redis INCR` instead.

Question 45

A synchronous method calls GetDataAsync().Result and the app hangs under load. Explain and fix.

Accepted Answer

In short: Blocking on async code ties up a thread while it waits. In a context with a synchronisation context it can deadlock. In ASP.NET Core it causes thread-pool starvation: every request blocks a thread, the pool grows slowly, and requests queue up. Fix: make the call chain async ( await ) from the controller down to the I/O call. If a sync API is truly unavoidable, use a properly synchronous library call rather than sync-over-async.

Question 46

You need to call 500 external URLs as fast as possible without getting rate-limited. How?

Accepted Answer

In short: Use async I/O with bounded concurrency : Parallel.ForEachAsync(urls, new ParallelOptions { MaxDegreeOfParallelism = 10 }, ...) or a SemaphoreSlim with Task.WhenAll . Reuse one HttpClient from IHttpClientFactory . Add retries with exponential backoff (Polly / Microsoft.Extensions.Http.Resilience ), respect 429 Retry-After , and pass cancellation tokens and timeouts.

Question 47

You must count error lines in a 5 GB log file without running out of memory. How?

Accepted Answer

In short: Stream it: foreach (var line in File.ReadLines(path)) if (line.Contains( ERROR , StringComparison.Ordinal)) count++; or a StreamReader with ReadLineAsync — memory stays constant because only one line is held at a time. Don t use ReadAllText / ReadAllLines . For more speed: a larger buffer ( new StreamReader(path, Encoding.UTF8, true, 1 16) ), Span -based searching, or splitting the file into ranges processed in parallel when the disk is fast.

Question 48

After deploying to the cloud, order times shown to users are 5.5 hours off. What went wrong?

Accepted Answer

In short: The code used DateTime.Now , which is the server s local time — the cloud server runs in UTC while the developer s PC ran in IST (or the opposite conversion was applied twice). Fix: store and compare in UTC ( DateTime.UtcNow / DateTimeOffset ), mark DateTimeKind.Utc when reading from the database, convert to the user s time zone ( TimeZoneInfo.ConvertTimeFromUtc ) only for display, send ISO 8601 with offset ( O format) in APIs, and inject TimeProvider so tests can control the time.

C# Language — Basics to Advanced