أسئلة القسم

.NET is a free, cross-platform, open-source developer platform for building applications (web, desktop, mobile, cloud, gaming, IoT).

Main components of .NET architecture:

• CLR (Common Language Runtime): Execution engine. Handles memory management, garbage collection, exception handling, JIT compilation.
• CTS (Common Type System): Defines how types are declared and used across all .NET languages (C#, VB, F#).
• CLS (Common Language Specification): A subset of CTS rules to ensure cross-language interoperability.
• BCL/FCL (Base Class Library / Framework Class Library): Provides reusable classes (collections, IO, networking, etc.)

JSON (JavaScript Object Notation) is a lightweight, text-based format for data exchange.

• Human-readable, language-independent, used in APIs.

• break → Exits the loop completely.
• continue → Skips current iteration, moves to next.

• == → Operator. By default, checks reference equality (for objects), value equality (for primitives/structs).
• .Equals() → Virtual method, can be overridden for custom equality.

const

• Compile-time constant
• Must be initialized inline
• Implicitly static

readonly

• Runtime constant
• Can be assigned in constructor
• Different value per instance possible

• Value types: 0 for numeric, false for bool, '\0' for char.
• Reference types: null.

for:

• Index-based
• Flexible (can manipulate index)

foreach:

• Cleaner, read-only iteration
• Can’t modify underlying collection size

String: Immutable → Every change creates a new object. StringBuilder: Mutable → Efficient for many modifications.

• Value types: Stored in stack, hold actual data. (e.g., int, struct).
• Reference types: Stored in heap, variable holds reference (e.g., class, string).

Stack: LIFO (Last In, First Out).

• Methods: Push(), Pop(), Peek().

Queue: FIFO (First In, First Out).

• Methods: Enqueue(), Dequeue(), Peek().

SortedDictionary<TKey, TValue>

• Backed by a binary search tree (red-black tree).
• Better for frequent inserts/deletes.

SortedList<TKey, TValue>

• Backed by arrays.
• Better for smaller collections and frequent lookups.

• IEnumerable: Forward-only iteration (foreach).
• ICollection: Extends IEnumerable, adds Count, Add, Remove.
• IList: Extends ICollection, supports index-based access.
• IDictionary: Key-value pairs, extends ICollection.

• IEnumerable: Represents a collection that can be iterated. Provides GetEnumerator().
• IEnumerator: Represents the enumerator that actually iterates. Provides MoveNext(), Current, Reset().

HashSet does not allow duplicates.

• Internally uses hashing; if hash code + equality match an existing item, new one is ignored.

• Uses a hash code of the key → bucket index.
• If multiple keys map to same bucket:
  • Uses equality comparer (Equals) to differentiate.
  • Stores colliding items in linked entries.
• In .NET Core, collisions are resolved with chaining.

A delegate is a type-safe reference to a method.

• Supports callback mechanisms, event handling, LINQ expressions.

Serialization: Converting an object into a format (JSON, XML, binary) to store or transfer.

• Example: Save object to a file or send over network.

Converting serialized data back into an object.

• ref → Passes variable by reference (must be initialized before).
• out → Passes variable by reference, but must be assigned inside method.
• in → Passes by reference but as readonly (cannot modify inside method).

Value parameter (default):

• A copy of the argument is passed.
• Changes inside the method don’t affect the original variable.

Ref parameter:

• Passes reference to the original variable.
• Must be initialized before passing.
• Changes inside the method affect the caller.

Shallow Copy:

• Copies object’s fields as is.
• Reference fields still point to the same objects.
• Example: MemberwiseClone().

Deep Copy:

• Copies the object and all referenced objects recursively.
• Requires custom implementation or serialization.

• is: Checks type compatibility, returns true/false.
• as: Attempts safe cast, returns null if it fails (no exception).

• Boxing: Converting a value type → object (heap allocation).
• Unboxing: Extracting value type from object.

• Iterator: A method that returns elements one at a time (lazy evaluation).
• yield return: Produces a value and remembers state for next iteration.
• yield break: Ends iteration.

• Tuple: Lightweight data structure, supports multiple values. Mutable.
  • Example: var t = Tuple.Create(1, "Book");
• Anonymous type: Compiler-generated class, read-only properties, scoped to method.
  • Example: var obj = new ;
• Key difference: Tuples are reusable return types, anonymous types are method-scoped.

Records are reference types introduced in C# 9, optimized for immutable, value-based equality.

Dictionary<TKey,TValue>:

• Not thread-safe for concurrent reads/writes.
• Needs external locking (lock) for multi-threading.

ConcurrentDictionary<TKey,TValue>:

• Designed for thread-safe concurrent access.
• Uses fine-grained locking and lock-free operations internally.
• Provides atomic methods like TryAdd, GetOrAdd, AddOrUpdate.

Span is a stack-only type for working with continuous memory (arrays, slices, stackalloc, unmanaged memory).

Benefits:

• Avoids allocations → no new arrays when slicing.
• Improves performance for parsing, processing large data.
• Safe alternative to pointers (bounds-checked).

Limitation: Cannot be stored on heap (because it references stack memory).

• Covariance (out): lets you use a more derived type than specified. Works with return values.
• Contravariance (in): lets you use a more generic (base) type than specified. Works with parameters.

JIT (Just-In-Time) compiles IL (Intermediate Language) to machine code at runtime.

Types:

• Pre-JIT (NGen/AOT): whole assembly ahead of time.
• Econo-JIT: compiles only needed methods, discards unused.
• Normal JIT: compiles as methods are called.

AppDomain: an isolation unit for .NET apps within a process.

• Used to load/unload assemblies without restarting the process.
• In .NET Core/.NET 5+, AppDomains are not supported → replaced with AssemblyLoadContext.

• Value types (int, bool) cannot be null by default.
• Nullable types (int?): wrap them in Nullable.
• Provides HasValue and Value.

By default:

• 1 MB for main thread.
• 256 KB – 1 MB for worker threads (depends on OS and settings).
• Can be configured using Thread constructor or PE header.

• Objects ≥ 85 KB (mainly large arrays, strings, buffers).
• Stored separately for performance (avoid frequent GC compaction).

• A GC heap segment optimized for small, frequently allocated objects.
• Introduced with Server GC in .NET 5+.
• Reduces contention by giving each thread its own heap segment.

• Generational GC: objects are grouped into Gen 0, Gen 1, Gen 2.
• Process:
  • Allocations go to Gen 0.
  • Short-lived → collected quickly.
  • Surviving objects promoted to higher generations.
  • Uses mark-and-sweep with compaction.

• Non-deterministic (can’t control exactly when GC runs).
• Finalizers delay cleanup.
• Expensive for large heaps (pauses).
• Not aware of unmanaged resources → need IDisposable.

Managed (.NET runtime):

• Pros: GC, memory safety, type safety, security.
• Cons: Overhead (GC pauses, JIT cost).

Unmanaged (C/C++):

• Pros: Full control, high performance.
• Cons: Risk of leaks, buffer overflows, manual memory management.

• Synchronous: blocks until operation completes.
• Asynchronous: frees the thread, continues when operation completes (non-blocking).

• async/await: syntactic sugar for working with Task.
• Improves responsiveness (UI not blocked, server scales better).
• Doesn’t create new threads (uses I/O completion).

• No, async methods don’t create new threads by default.
• I/O-bound async uses I/O completion ports.
• CPU-bound async needs Task.Run() (creates a thread).

• Thread: OS thread, heavy, long-lived.
• Task: abstraction for async work, can use thread pool or I/O.
• ValueTask: lightweight struct for performance when result is often available synchronously.

Use synchronization primitives:

• lock (monitor).
• Mutex, SemaphoreSlim, ReaderWriterLockSlim.

Collections in System.Collections.Concurrent:

• ConcurrentDictionary, ConcurrentBag, BlockingCollection, ConcurrentQueue, ConcurrentStack.
• Provide lock-free or fine-grained locking.

• When multiple threads access shared state.
• Ensures only one thread executes a block at a time.