Top 10 Sample

Question

TECHNICAL INTERVIEW
PREPARATION GUIDE
C#, .NET, SQL, OOPS, WEB
API, ENTITY FRAMEWORK
Comprehensive Questions & Answers
CodewithIndu
 OOPS&C#-Basics
Q1. What is C#? What is the difference between C# and .NET ?
Ans- C# (C-Sharp) is a modern, object-oriented programming
language developed by Microsoft.
It is used to build secure, scalable, and high-performance applications
such as web applications, desktop software, web APIs, mobile apps,
cloud services, and games (Unity).
Key Points
1. Strongly-typed
2. Object-oriented
3. Component-based
4. Runs on the .NET platform
5. Designed for reliability and scalability
.NET is a complete software development platform that provides the
runtime (CLR), libraries, tools, and frameworks needed to build and
run applications written in C#, F#, or [Link].
Key Components of .NET
[Link] (Common Language Runtime): Executes code
2. BCL (Base Class Library): Pre-built functions
3. [Link] Core: For web apps & APIs
4. Entity Framework Core: For data access
5. MAUI/Xamarin: For mobile apps
Real-World Example
Project Example: School Management System
• You write classes like Student, Teacher, Attendance in C#.
• You build your web application using [Link] Core (part of the
.NET platform).
• The .NET runtime executes your C# code.
• Entity Framework Core handles the database operations.
So:
• C# = Code (Logic)
• .NET = Platform (Execution + Tools)

Q2. What is OOPS? What are the main concepts of OOPS?

Ans-OOPS (Object-Oriented Programming System) is a
programming model that organizes software design around objects
rather than functions and logic.
Is a way of code where we create objects (real- world models) to
represent data and behaviour.
Its helps to write clean, reuseable and easy- to – maintain code.
An object = data (properties) + behaviour (methods).
Definition-
OOPS is a programming paradigm based on the concept of “objects”
that helps create reusable, maintainable, scalable, and secure
applications.
There are 4 main pillars of OOPS.
1. Encapsulation
2. Abstraction
3. Inheritance
4. Polymorphism
• Encapsulation- “Data hiding”
 Encapsulation means wrapping data (variables) and methods
(functions) into a single unit called a class and protecting the data
using access modifiers.
Example- A capsule contains medicine inside and protects it.
Similarly, a class hides internal data and exposes only required
features.
Code-
class Student {
private int age; // hidden data
public void SetAge (int a) {
age = a;
}
}
┌─────────────┐
│ CLASS │
│-------------│
│ private data│ ← hidden
│ public method│ ← controlled access
└─────────────┘
• Abstraction- Abstraction means showing only essential details
and hiding the complex internal logic.
• Inheritance- Inheritance allows one class (child) to reuse the
properties and methods of another class (parent).
• Polymorphism- Polymorphism means “many forms.” It allows
the same method to behave differently depending on the object.
Q3. What are the advantages of OOPS?
Ans- The advantages of OOPS (Object-Oriented Programming
System) are the benefits it provides while designing software using
objects, such as improved code organization, reusability, security,
flexibility, and maintainability.
Top Advantages of OOPS
1. Reusability (Code Reuse)
OOPS allows developers to reuse classes and behaviour instead of
writing the same code again.
Real-World Example
A Car base class can be reused to create Honda, BMW, Audi classes.
Benefit
Saves time, reduces errors, improves consistency.

2. Data Security (Encapsulation)

OOPS protects data using access modifiers like private, protected,
public.
Real-World Example
A Bank Account hides its balance and exposes only
deposit/withdraw methods.
Benefit
Prevents unauthorized access & improves safety.
3. Better Maintainability
OOPS divides the project into small, independent objects/classes.
Real-World Example
Changing the Student class does not force changes in Teacher class.
Benefit
Easier to maintain, update, and debug.
4. Abstraction (Hides Complexity)
OOPS hides unnecessary internal details and shows only essential
features.
Real-World Example
A Car’s steering hides complex engine mechanics.
Benefit
Cleaner interfaces, easier to understand and use.
5. Flexibility & Extensibility (Using Polymorphism)
OOPS allows methods to behave differently based on objects.
Real-World Example
A Draw () method behaves differently for Circle, Rectangle, Triangle.
Benefit
Flexible design and easy extension.
6. Code Organization (Class & Object Structure)
OOPS organizes large projects into classes making the system
structured.
Real-World Example
E-commerce app has separate classes: Product, Order, User, Cart.
Benefit
Clear architecture, modular design.
7. Improved Productivity
Using reusable classes, inheritance, and templates reduces
development time.
Real-World Example
Developers can quickly create new screens/features using existing
base classes.
Benefit
Software is built faster with fewer bugs.

Q4. What are the limitations of OOPS?

Ans- Limitations of OOPS are the disadvantages, challenges, or
situations where object-oriented programming does not perform
well or becomes unnecessarily complex.
Main Limitations of OOPS
1. More Complex to Understand and Implement
OOPS concepts (inheritance, polymorphism, abstraction) can be
difficult for beginners.
Real-World Example
A simple script (like reading a file) becomes unnecessarily
complicated when wrapped inside multiple classes.
2. Slower Performance Compared to Procedural Programming
OOPS uses dynamic dispatch, object creation, and garbage
collection which make execution a bit slower.
Real-World Example
High-performance systems like OS kernels prefer C (procedural)
over OOP.
3. Larger Memory Usage
Objects, class definitions, metadata, and runtime support require
more memory.
Real-World Example
A simple calculator built using heavy OOP design may consume
more RAM than needed.

4. Not Suitable for Small Programs

Small tasks (like reading/writing a file, printing logs) become
complicated with OOPS structure.
Real-World Example
Creating classes like PrintUtility, FileReader, FileWriter for small
scripts is overkill.

5. Risk of Over-Engineering (Too Much Abstraction)

Developers may create unnecessary classes, interfaces, or
inheritance chains.
Real-World Example
Creating 7 layers of inheritance for a simple feature → makes
debugging difficult.
6. Tight Coupling Due to Inheritance
Incorrect use of inheritance increases dependency between
classes.
Real-World Example
If a parent class changes, all child classes must be updated.

7. Parallel/Multithreaded Programming Becomes Difficult

Managing multiple objects in parallel is complex and requires extra
synchronization.
Real-World Example
Large banking systems with multiple transactions face concurrency
challenges.

8. Not Ideal for Functional Requirements

Functional programming (like LINQ, Streams, Lambda) gives better
performance in some scenarios.
Real-World Example
Data transformation pipelines are easier in functional than OOP
style.
┌──────────────────────────────┐
│ Limitations of OOPS │
└──────────────────┬────────────┘
│
┌──────────────────────────────┼
──────────────────────────────┐
│ │ │
More Complexity Slower Performance Over-Engineering
│ │ │
Hard for Beginners More Memory Usage Deep
Inheritance Chains
│
Not Suitable for Small Programs
 Q5. What are Classes and Objects?
Ans- A class is a blueprint or template that defines the structure
and behavior (properties and methods) of objects.
It does not occupy memory until an object is created.
Example-
A Blueprint of a House
• The blueprint is not a real house
• It only describes how the house should look
Similarly,
• A class is a blueprint
• It describes how objects will look and behave
Code Example
class Student {
public string Name;
public int Age;

public void Study() {

[Link]("Student is studying");
}
}
Object
An object is an instance of a class. It represents a real entity created
using the class blueprint.
Objects occupy memory and can interact with each other.
Example-
Using the previous example:
Blueprint = Class
Actual House = Object
Code Example
Student s1 = new Student(); // s1 is an object
[Link] = "John";
[Link] = 20;
[Link]();
┌─────────────────────────┐
│ CLASS │
│ (Blueprint / Template) │
│---------------------------│
│ Properties + Methods │
└───────────┬─────────────┘
│ Create Object
▼
┌──────────────────────────────────┐
│ OBJECT │
│ (Real Instance in Memory) │
│ Example: Name = "John", Age = 20 │
└──────────────────────────────────┘
“A class is a blueprint or template that defines the properties and
behaviors of an entity.
An object is an instance created from that class.
A class describes what the object will contain, while the object holds
the actual data in memory.
For example, if ‘Car’ is a class, then the specific cars like BMW, Audi,
and Honda are objects created from that class.”

Q6. What are the types of classes in C#?

Ans- In C#, the main types of classes are:
1. Static Class
2. Sealed Class
3. Abstract Class
4. Partial Class
5. Concrete/Normal Class
6. Generic Class
7. Nested Class
Each class type serves a unique purpose such as inheritance control,
code reusability, abstraction, or structure organization.
1. Concrete (Normal) Class
Definition - A normal class that can be instantiated (objects can be
created).
Example
class Student {
public string Name;
}
Student s = new Student(); // object created
2. Static Class
 Definition - A class that cannot be instantiated and contains only
static members.
Key Points
• No objects can be created
• Automatically sealed (cannot be inherited)
• Used for helper/utility functions
Example
static class MathHelper {
public static int Add(int x, int y) => x + y;
}
[Link] Class
Definition
A class that cannot be instantiated and may contain abstract
methods.
Purpose
To provide a base structure for derived classes.
Example
abstract class Animal {
public abstract void Sound();
}
class Dog : Animal {
public override void Sound() => [Link]("Bark");
}
4. Sealed Class
Definition
A class that cannot be inherited.
Purpose
• Prevent modification
• Improve performance in some cases
Example
sealed class Payment { }
[Link] Class
Definition
A class split across multiple files, combined at compile time.
Purpose
Useful for:
• Large classes
• Auto-generated + custom code separately (e.g., [Link], EF)
Example
File 1:
partial class Employee {
public string Name;
}
File 2:
partial class Employee {
public void Work() { }
}
6. Generic Class
Definition
Class that works with different data types without duplication.
Example
class Box<T> {
public T Value;
}
Box<int> intBox = new Box<int>();
Box<string> strBox = new Box<string>();
7. Nested Class
Definition
A class declared inside another class.
Purpose
Used when a class is logically part of another.
Example
class Outer {
class Inner {
public void Show() { }
}
}
“C# supports several types of classes such as Normal classes, Static
classes, Abstract classes, Sealed classes, Partial classes, Generic
classes, and Nested classes.
Each type serves a specific purpose—for example, static classes
prevent object creation, abstract classes enforce base structure,
sealed classes restrict inheritance, partial classes split code for
maintainability, and generic classes help reusability with different
data types.”

Q7. Is it possible to prevent object creation of a class in C#?

Ans- Yes, we can prevent object creation of a class in C# using any of
the following ways:
1. Mark the class as static.
2. Make the constructor private.
3. Mark the class as abstract.

Each method prevents creation of objects in different scenarios.

1. Static Class

Definition

A static class cannot be instantiated.

Compiler does not allow creating objects from it.

Example

static class Logger

public static void Log(string msg) { }

// Logger obj = new Logger(); ❌ Not allowed

When to Use

Utility classes like: MathHelper, Logger, ConfigManager.

Private Constructor

Definition

If the constructor is private, no object can be created from outside the

class.

Example

class DatabaseConnection

private DatabaseConnection() { }

public static void Connect() { }

// DatabaseConnection db = new DatabaseConnection(); ❌ Not

allowed

Real-World Use

Used in Singleton Pattern, Helper classes, Framework classes.

[Link] Class

Definition

Abstract class cannot be instantiated, but can be inherited.

Example

abstract class Shape

{

public abstract void Draw();

// Shape s = new Shape(); ❌ Not allowed

Use Case

When you want to force child classes to give implementation.

Q8. What is Property?

Ans- A Property in C# is a class member that provides a flexible way

to read, write, or compute values of private fields.
It acts like a bridge between private data and the outside world,
ensuring data encapsulation and validation.

Properties use get and set accessors:

• get → returns the value

• set → assigns the value (with validation if needed)

Simple

Think of a property as a controlled door to a room (private field).

You can open it (get) or close it (set), but rules can be applied.

Example (Bank Account)

In real life, you cannot directly change your bank balance.

You update it through controlled methods (deposit, withdraw).

Same in C#:

We don’t expose balance directly, we use a Property to control

access.
Example:

public class BankAccount

private double _balance; // Private field

public double Balance

get { return _balance; } // Read balance

private set // Only class can set it

if (value >= 0)

_balance = value;

public void Deposit(double amount)

Balance = Balance + amount;

}
Q9. What is the difference between Property and Function?

Ans- Property A Property is a class member that provides

controlled access to private fields using get and set accessors.
It is used to store or retrieve data and generally should not perform
heavy operations.

🔹 Function (Method)

A Function/Method is a block of code that performs actions,

computations, or business logic.
It may take parameters, return values, and execute complex
operations.

Simple Understanding

Concept Easy Meaning

Property Like a door to access private data (open/get, close/set).
Like a machine that takes input, performs work, and outputs
Function
results.

Real-World Example (Bank ATM)

Property Example

Your Bank Balance is accessed safely:

• You can read it (get)

• You may not directly set it

public double Balance { get; private set; }

Balance is data → property is correct.

Function Example

Depositing or withdrawing money requires logic:

public void Deposit(double amount)

{

Balance += amount;

Deposit is an action → function is correct.

Difference

Feature Property Function (Method)

Purpose To expose data safely To perform actions or logic
Accessors Uses get and set Uses method body with ()
Usage Treated like a field Called as an operation
Syntax [Link] [Link]()
Can have multiple
Parameters Usually no parameters
parameters
Usually returns or sets a
Return Value Can return anything or void
field
Should be simple and
Workload Can be complex and heavy
light
Usage in
Treated as data member Not used as property
LINQ
Memory Can store data Does not store data

Code Example (Clear and Simple)

Property

public string Name { get; set; }

Function

public string GetFullName()

return FirstName + " " + LastName;}

Q10. What are Namespaces?

Ans- A Namespace in C# is a logical grouping of related classes,

interfaces, enums, and other code elements.
It helps organize code, avoid name conflicts, and manage large
projects.

Think of a namespace as a folder in your computer that contains

related files.

Real-World Example

Imagine a large company with different departments:

• HR Department
• IT Department
• Finance Department

Each department has an employee named "John"—but they are in

different departments, so there is no conflict.

Similarly:

• [Link]
• [Link]
• [Link]

All can exist without conflict because they live in different

namespaces.

C# Example

Creating a namespace

namespace [Link]

public class Employee

{
 public string Name { get; set; }

Another namespace with same class name

namespace [Link]

public class Employee

public string Name { get; set; }

Using a Namespace

using [Link];

Employee emp = new Employee();