أسئلة القسم

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.