أسئلة القسم

Object-Oriented Programming (OOP) is a paradigm that organizes software design around objects instead of functions and logic.

Main Principles (Pillars):

• Encapsulation: Hiding internal details, exposing only necessary behavior.
• Inheritance: Reusing and extending existing classes.
• Polymorphism: Ability for different classes to be treated through a common interface.
• Abstraction: Focusing on essential behavior, hiding complexity.

An object is an instance of a class.

It represents a real-world entity with state (fields/properties) and behavior (methods).

Encapsulation = wrapping data + methods together and controlling access via access modifiers.

Protects internal state, only exposes what’s necessary.

Example:

public class BankAccount {
    private decimal balance; // hidden from outside
    public void Deposit(decimal amount) => balance += amount;
    public decimal GetBalance() => balance;
}

Inheritance allows one class (child) to reuse and extend another class (parent).

Promotes code reuse.

Example:

class Vehicle { public void Drive() => Console.WriteLine("Driving..."); }
class Car : Vehicle { public void Honk() => Console.WriteLine("Beep!"); }

Car car = new Car();
car.Drive(); // inherited
car.Honk();  // child’s own

Polymorphism = “many forms” → same method name can behave differently depending on the context.

Types:

1. Compile-time Polymorphism (Static)
   • Achieved using method overloading or operator overloading.
   • Decided at compile time by the compiler.
2. Runtime Polymorphism (Dynamic)
   • Achieved using method overriding with virtual/override.
   • Decided at runtime by the CLR.

Abstraction = hiding implementation details, exposing only what an object does, not how.

Done using abstract classes or interfaces.

A constructor is a special method (with the same class name) that runs when an object is created.

Used to initialize fields/properties.

• Default constructor: No parameters.
• Parameterized constructor: Takes arguments.
• Copy constructor: Copies values from another object.
• Static constructor: Runs once, initializes static data.
• Private constructor: Prevents direct instantiation, often used in Singleton.

Constructor:

• Called when object is created.
• Used for initialization.

Destructor (~ClassName):

• Called by GC before object is destroyed.
• Used for cleanup (rare in C#, usually replaced by IDisposable).

Yes.

Common Use Cases:

• Singleton pattern: Restricts instantiation.
• Static classes: Prevents object creation.

A class declared with static keyword:

• Cannot be instantiated.
• Can only contain static members.
• Often used for utility/helper methods.

No, a static class cannot implement an interface because:

• Static classes cannot be instantiated.
• Interfaces define a contract meant to be implemented by instances of classes.

Abstract Method:

• No implementation in base class.
• Must be overridden in derived class.

Virtual Method:

• Has a default implementation.
• Can be overridden (optional).

• Regular class: Normal type.
• Abstract class: Cannot be instantiated.
• Sealed class: Cannot be inherited.
• Static class: Contains only static members.
• Partial class: Split across multiple files.
• Nested class: Class inside another class.

Sealed class: Cannot be inherited.

Used when:

• You want to prevent inheritance for security or design reasons.
• For performance (JIT optimizes sealed methods).

Partial class: Lets you split a class across multiple files using the partial keyword.

Commonly used in auto-generated code (e.g., Entity Framework, WinForms).

Limitations:

• All parts must have partial.
• Must be in the same assembly and namespace.
• Cannot span multiple assemblies.

Extension method: A static method that appears as if it’s part of an existing type.

Declared in a static class with this keyword on the first parameter.

Use case: Add methods to existing classes (e.g., LINQ adds extension methods to IEnumerable<T>).

Virtual method: A method in a base class marked with virtual.

• Can be overridden in a derived class using override.
• Provides runtime polymorphism.

No.

Structs are value types and do not support inheritance, so virtual/abstract methods are not allowed.

However, structs can implement interfaces.

• override: Used when the base method is marked virtual, abstract, or override. It replaces the base implementation.
• new: Hides the base class method. The base method still exists but is hidden in the derived class.

Key difference: override = polymorphism (runtime binding). new = method hiding (compile-time).

No, C# does not allow multiple inheritance of classes.

Reason: To avoid diamond problem (ambiguity when two parents have the same method/property).

Instead: C# supports multiple interfaces.

Yes, a class can implement multiple interfaces.

This is how C# provides multiple inheritance of behavior safely.

The out keyword means the called method is responsible for assigning a value before returning.

Commonly used for methods returning multiple values.

Object initializer: Provides a clean way to initialize properties when creating an object.

Reduces need for multiple constructors.

• Early Binding (compile-time): Type and method resolution happens at compile-time (e.g., method calls on normal objects).
• Late Binding (runtime): Resolution happens at runtime (e.g., reflection, dynamic).

Generics allow type-safe, reusable code without sacrificing performance.

Example: List<T>, Dictionary<TKey, TValue>.

• Covariance (out): Allows a method to return a more derived type (e.g., IEnumerable<Derived> → IEnumerable<Base>).
• Contravariance (in): Allows a method to accept less derived type (e.g., Action<Base> → Action<Derived>).
• Invariance: No conversion allowed.

Indexer: Special property that lets a class/struct be accessed like an array.

Dispose() is not called automatically by the CLR.

It must be called explicitly by:

• The developer (obj.Dispose()), or
• The using / using declaration statement, which ensures automatic disposal.

It is typically called when you are done using an object that holds unmanaged resources (e.g., file handles, DB connections).

No, collections like List<T>, Dictionary<TKey,TValue> are not thread-safe.

For thread-safe alternatives, .NET provides Concurrent Collections (ConcurrentDictionary, BlockingCollection, etc.).

CLR uses a vtable (virtual method table) for virtual/abstract/override methods.

Each type has a vtable mapping method slots → function pointers.

When calling a virtual method:

• CLR looks up the object’s type.
• Jumps to the appropriate method pointer in the vtable.

Non-virtual methods = direct calls (no vtable lookup).

CLR performs a vtable lookup at runtime.

The exact implementation (base or derived) is resolved based on the object’s runtime type, not compile-time type.

This enables runtime polymorphism.

Object slicing: In C++ when assigning a derived object to a base object by value, extra fields are "sliced off".

In C#: This doesn’t apply because:

• Objects are reference types by default.
• Only value types (structs) could cause similar behavior, but C# disallows slicing scenarios directly.

CLR creates separate interface method tables.

If two interfaces declare the same method signature:

• A single implementation can satisfy both.
• Or explicit interface implementation can disambiguate.

GC: Manages memory for managed objects (allocates on heap, reclaims unreachable ones).

IDisposable: Allows deterministic cleanup of unmanaged resources before GC collects the object.

Together: GC frees managed memory, Dispose() handles unmanaged resources (files, sockets, DB connections).

Diamond problem: In multiple inheritance, ambiguity arises when two base classes define the same method.

C# solution:

• No multiple class inheritance.
• Multiple interface inheritance is allowed, and ambiguity is solved via explicit interface implementation.