C# Interview Mastery - Pro Edition

1. Abstract Class vs Interface

#	Abstract Class	Interface
1	Can have fields & constructors	No fields or constructors
2	Single inheritance	Multiple inheritance
3	Can have implemented methods	Only declarations (C# 8+ default)
4	Access modifiers allowed	All public by default
5	Share common code	Define contract

            abstract class Animal { public abstract void Speak(); }

            interface IDrive { void Drive(); }

            class Dog : Animal { public override void Speak() => Console.WriteLine("Woof"); }

            class Car : IDrive { public void Drive() => Console.WriteLine("Vroom"); }

2. Delegate vs Event

#	Delegate	Event
1	Type-safe function pointer	Wrapper over delegate
2	Can be invoked directly	Only publisher can raise
3	No encapsulation	Encapsulated
4	Used in LINQ, async	Used in GUI, notifications
5	Anyone can call	Only class can raise

            public delegate void Notify();

            public event Notify OnNotify;

            Notify handler = () => Console.WriteLine("Called");

            handler(); // Direct call

            OnNotify += () => Console.WriteLine("Event");

            // OnNotify(); // Error

3. Static vs Singleton

#	Static Class	Singleton
1	No instance	One instance
2	Cannot inherit	Can inherit/implement
3	Hard to test	Easy to mock
4	Loaded at start	Lazy loading
5	No DI	Supports DI

            public static class MathUtils { public static int Add(int a, int b) => a + b; }

            public class Logger {

              private static Logger _instance;

              private Logger() {}

              public static Logger Instance => _instance ??= new Logger();

              public void Log(string msg) => Console.WriteLine(msg);

            }

4. ref vs out

#	ref	out
1	Must initialize before	No init required
2	Can read inside	Cannot read before assign
3	Optional assign	Must assign
4	Modify existing	Return new value
5	Two-way	Output-only

            void Modify(ref int x) { x += 10; }

            void Get(out int x) { x = 100; }

            int a = 5; Modify(ref a); // a = 15

            int b; Get(out b); // b = 100

5. string vs StringBuilder

#	string	StringBuilder
1	Immutable	Mutable
2	New object on change	Same object
3	Slow in loops	Fast in loops
4	String pool	Dynamic buffer
5	Fixed text	Dynamic text

            string s = "Hi"; s += " there"; // New object

            StringBuilder sb = new("Hi");

            sb.Append(" there"); // Same object

6. Boxing vs Unboxing

#	Boxing	Unboxing
1	Value → Object	Object → Value
2	Stack → Heap	Heap → Stack
3	Implicit	Explicit cast
4	Allocates memory	Copies value
5	Slower	Slower + exception risk

            int i = 10;

            object obj = i; // Boxing

            int j = (int)obj; // Unboxing

7. IEnumerable vs IQueryable

#	IEnumerable	IQueryable
1	In-memory	Database-side
2	LINQ to Objects	LINQ to SQL
3	Client execution	Server execution
4	Slower for big data	Faster (SQL)
5	List, Array	DbContext

            List list = new() {1,2,3};

            var q1 = list.Where(x => x > 1); // IEnumerable

            var q2 = db.Users.Where(u => u.Age > 18); // IQueryable

8. Thread vs Task

#	Thread	Task
1	Low-level	High-level
2	OS managed	ThreadPool
3	Heavy	Lightweight
4	No async/await	Supports async
5	Manual control	Auto managed

            new Thread(() => Console.WriteLine("Thread")).Start();

            Task.Run(() => Console.WriteLine("Task"));

9. const vs readonly

#	const	readonly
1	Compile-time	Runtime
2	Primitives only	Any type
3	Implicit static	Can be instance
4	Never changes	Set in constructor
5	Substituted in IL	Stored in memory

            public const double Pi = 3.14;

            public readonly int Id;

            public MyClass(int id) => Id = id;

10. == vs .Equals()

#	==	.Equals()
1	Reference (default)	Value (if overridden)
2	Can overload	Can override
3	Fast	Slightly slower
4	String: content	String: content
5	Null safe	Risk of NullRef

            string a = "hi", b = "hi";

            a == b // True (content)

            a.Equals(b) // True

            object o1 = new(), o2 = new();

            o1 == o2 // False (reference)

            o1.Equals(o2) // False

11. What is C#?

Answer: C# is a modern, object-oriented programming language developed by Microsoft. It runs on the .NET Framework and is designed to be simple, type-safe, and scalable. It combines the power of C/C++ with the ease of Java.

            // C# is used to build Windows apps, Web APIs, Games (Unity), etc.

            Console.WriteLine("Hello, C#!");

Use Case: Enterprise apps, desktop, web, mobile (Xamarin), cloud (Azure).

12. What is Visual Studio?

Answer: Visual Studio is Microsoft's IDE for developing, debugging, and deploying .NET applications. It supports C#, VB.NET, F#, and more.

Features: Code Editor, Debugger, IntelliSense, Designer, Compiler, Git Integration.

// Write → Build → Run → Debug → Publish — all in one tool

13. What is Common Language Runtime (CLR)?

Answer: CLR is the execution engine of .NET. It manages code execution, memory, security, and garbage collection.

Key Roles: JIT Compilation, Exception Handling, Type Safety, GC.

C# → CIL (MSIL) → JIT → Native Machine Code

14. Data Types in C# (Value vs Reference vs Pointer)

#	Value Type	Reference Type	Pointer Type
1	Stores value	Stores address	Stores memory address
2	Stack	Heap	Unsafe context
3	Copy on assign	Reference copy	Direct memory access
4	int, bool, struct	class, string, array	int, char
5	Fast, independent	Shared object	Rare, unsafe

            int a = 10; int b = a; // Value copy

            string s1 = "Hi"; string s2 = s1; // Reference copy

            unsafe { int* p = &a; } // Pointer

15. Types of Operators in C#

Categories:

Arithmetic: +, -, *, /, %
Relational: ==, !=, <, >, <=, >=
Logical: &&, ||, !
Assignment: =, +=, -=, *=
Increment/Decrement: ++, --
Bitwise: &, |, ^, ~
Ternary: condition ? true : false
Null Coalescing: ??

            int x = 10;

            bool result = (x > 5) ? true : false;

            string name = null;

            string output = name ?? "Guest";

16. Types of Constructors in C#

Type	Description	Example
Default	No params	`public Person() {}`
Parameterized	Takes input	`public Person(string n)`
Copy	Copies object	`public Person(Person p)`
Static	Runs once	`static Person() {}`
Private	Singleton	`private Person() {}`

            class Person {

              public Person() {} // Default

              public Person(string n) {} // Param

              static Person() { Console.WriteLine("Static"); }

            }

17. What is Destructor in C#?

Answer: Destructor (~ClassName) is called by GC to clean up unmanaged resources. Implicitly invoked.

            class FileHandler {

              ~FileHandler() {

                Console.WriteLine("File closed");

              }

            }

Note: Use IDisposable + Dispose() for deterministic cleanup.

18. Garbage Collection in C#

Generation	Purpose
Gen 0	Short-lived (temp vars)
Gen 1	Medium-lived
Gen 2	Long-lived (static, cache)

            GC.Collect(); // Force GC (avoid in prod)

            GC.SuppressFinalize(this); // After Dispose()

Dispose vs Finalize: Dispose = manual, Finalize = automatic by GC.

19. Four Pillars of OOP

Pillar	Description
Encapsulation	Data + Methods in class, hide internals
Abstraction	Show essential, hide complex
Inheritance	Reuse code via parent-child
Polymorphism	One name, many forms

            // Polymorphism Example

            Animal a = new Dog(); a.Speak(); // "Woof"

20. Call by Value vs Call by Reference

#	Call by Value	Call by Reference
1	Copy passed	Address passed
2	No change to original	Original modified
3	Default	Use `ref` / `out`

            void Inc(int x) { x++; } // Value

            void IncRef(ref int x) { x++; } // Reference

21. Value Type vs Reference Type

#	Value Type	Reference Type
1	Stack	Heap
2	Copy on assign	Reference copy
3	struct, int	class, string

22. ref vs out Keyword

#	ref	out
1	Must initialize	No init needed
2	Can read	Cannot read before assign
3	Optional assign	Must assign

23. Abstract Class vs Interface

#	Abstract Class	Interface
1	Can have fields	No fields
2	Single inheritance	Multiple
3	Constructors	No constructors

24. Overloading vs Overriding

#	Overloading	Overriding
1	Same class	Parent-child
2	Different params	Same signature
3	Compile-time	Runtime

25. Stack vs Heap Memory

#	Stack	Heap
1	Value types	Reference types
2	Fast, auto-clean	GC managed
3	Limited size	Large, dynamic

26. Managed vs Unmanaged Code

#	Managed	Unmanaged
1	CLR control	Direct OS
2	GC	Manual free
3	C#	C++, COM

27. Dispose() vs Finalize()

#	Dispose	Finalize
1	Manual call	GC auto
2	IDisposable	~Class()
3	Deterministic	Non-deterministic