Csharp Programming Practice Exam

Question 1 Csharp Programming

What is a verbatim string and when is it used?

List<T> is an ordered, indexable sequence. Contains is O(n).
HashSet<T> is an unordered collection of unique items with O(1) Contains, Add, Remove.

Use HashSet for membership tests and deduplication; use List when order and indexing matter. Verbatim strings (prefix @) disable escape processing and allow multi-line text:

var path = @"C:\Users\Alice\file.txt";
var multi = @"line 1
line 2";

To include a ", double it: @"He said ""hi"".". Combine with $ for interpolated verbatim strings: $@"Path: {path}".

Read-only collections (ReadOnlyCollection<T>, IReadOnlyList<T>) — wrappers around a mutable collection. The interface prevents mutation, but the underlying collection can still change.
Immutable collections (System.Collections.Immutable) — truly immutable trees; every modification returns a new instance with structural sharing.

Use immutable collections in concurrent code or when you need real immutability. Exceptions in async methods are captured in the returned Task. Use try/catch with await:

try {
  await SomeAsyncMethod();
} catch (HttpRequestException ex) {
  Console.WriteLine(ex.Message);
}

Without await, the exception goes unobserved unless the task is inspected.

Question 2 Csharp Programming

What is the standard event pattern in C#?

yield return lets an iterator method produce values one at a time, lazily:

IEnumerable<int> Range(int n) {
  for (int i = 0; i < n; i++) yield return i;
}

The compiler generates a state machine. yield break terminates the iterator early. Each call to GetEnumerator() returns a fresh enumerator. IEquatable<T> defines bool Equals(T other) for type-safe, allocation-free equality:

struct Point : IEquatable<Point> {
  public bool Equals(Point p) => X == p.X && Y == p.Y;
}

Implement it on value types and on custom types that define value equality. Dictionary and HashSet use it (via EqualityComparer<T>.Default) to avoid boxing. The standard pattern uses EventHandler<TEventArgs>:

public event EventHandler<MyEventArgs> OnAction;

protected virtual void RaiseAction(MyEventArgs e) {
  OnAction?.Invoke(this, e);
}

MyEventArgs should derive from EventArgs.

Covariance (out T) – allows a generic type to be used as a more derived type: IEnumerable<string> → IEnumerable<object>
Contravariance (in T) – allows a less derived type: Action<object> → Action<string>

Applies to interfaces and delegates.

Question 3 Csharp Programming

What is the IDisposable pattern and the dispose pattern?

IAsyncDisposable (.NET Core 3.0+) is the async counterpart of IDisposable:
public async ValueTask DisposeAsync() { await FlushAsync(); }
Use it when cleanup involves async I/O (flushing buffers, closing network connections). The await using statement disposes asynchronously. Many types implement both — the runtime calls DisposeAsync when used with await using. For classes holding unmanaged resources, implement IDisposable and follow the dispose pattern:

public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); }
protected virtual void Dispose(bool disposing) { /* free unmanaged; if (disposing) free managed */ }
~MyClass() { Dispose(disposing: false); }

Callers use using; finalizer is a safety net. The modern alternative is to avoid finalizers by using SafeHandle. An auto-implemented property lets the compiler generate the backing field automatically:
public int Age { get; set; }
You can also set access levels: public string Name { get; private set; }
Use init for immutable initialization: public string Id { get; init; } Polymorphism lets a derived class be treated as its base type. Subtype polymorphism is enabled by virtual/override methods, so the actual runtime type determines which method runs:

Animal a = new Dog();
a.Speak(); // "Woof" if Speak is virtual+overridden

Without virtual, the base implementation runs even for derived instances. C# also has parametric polymorphism (generics) and ad-hoc polymorphism (overloads / operator overloading).

Question 4 Csharp Programming

What is the sealed keyword in C#?

sealed prevents a class from being inherited or a method from being further overridden:
public sealed class Singleton { }
On a method:
public sealed override string ToString() => "fixed";
Sealed classes can offer slight performance benefits due to devirtualization. LINQ (Language Integrated Query) is a set of features that allows you to write query expressions directly in C# to filter, sort, and transform data from collections, databases, and XML.
var results = list.Where(x => x > 5).OrderBy(x => x);

Ordinal compares raw Unicode code units — fast, culture-independent, deterministic. Best for internal data, file paths, and security checks.
CurrentCulture uses the current culture's collation rules — appropriate for user-visible text like sorted lists.

Use OrdinalIgnoreCase for case-insensitive matching of internal identifiers. .NET 6+ ships throw helpers to reduce boilerplate validation:

ArgumentNullException.ThrowIfNull(arg)
ArgumentException.ThrowIfNullOrEmpty(arg)
ArgumentException.ThrowIfNullOrWhiteSpace(arg)

Pass paramName: and message: as needed. Prefer them over hand-rolled if (x == null) throw ....

Question 5 Csharp Programming

What is the CallerMemberName attribute used for?

string.IsNullOrEmpty(s) returns true if s is null or "".
string.IsNullOrWhiteSpace(s) also returns true for strings containing only whitespace (spaces, tabs, newlines).

Use IsNullOrWhiteSpace for user input validation. Local functions are methods declared inside another method:

void Outer() {
  int Inner(int x) => x * 2;
  Console.WriteLine(Inner(5));
}

They capture variables from the enclosing scope. Unlike lambdas, they can be static (no capture, no closure allocation), generic, and async. They are emitted as real methods, not delegates. Reflection (System.Reflection) lets you inspect and manipulate types at runtime: get properties, methods, attributes, and invoke them dynamically:

var t = typeof(MyClass);
var props = t.GetProperties();
var inst = Activator.CreateInstance(t);

Powerful but slow and unsafe (no compile-time checks). Common in DI containers, ORMs, and serializers. Prefer Source Generators or expression trees for performance-critical paths. [CallerMemberName] auto-fills a parameter with the name of the calling member at compile time:
void Raise(string name = "", [CallerMemberName] string caller = "") => ...
Common in INotifyPropertyChanged implementations so you don't repeat property names as strings. Related: [CallerFilePath], [CallerLineNumber].

Question 6 Csharp Programming

What is PLINQ in C#?

SortedList<TKey, TValue> — backed by a sorted array. O(log n) lookup, but O(n) insert/remove (shifts).
SortedDictionary<TKey, TValue> — backed by a red-black tree. O(log n) for all operations, but higher memory overhead per node.

Use SortedList when inserts are rare and lookups dominate; SortedDictionary for balanced insert/lookup patterns. Exceptions in async methods are captured in the returned Task. Use try/catch with await:

try {
  await SomeAsyncMethod();
} catch (HttpRequestException ex) {
  Console.WriteLine(ex.Message);
}

Without await, the exception goes unobserved unless the task is inspected. ArrayPool<T>.Shared rents and returns pre-allocated arrays from a shared pool:

var buf = ArrayPool<byte>.Shared.Rent(1024);
try { /* use buf */ } finally { ArrayPool<byte>.Shared.Return(buf); }

Useful in I/O paths to avoid repeated allocations. Span<T> can wrap the rented array for zero-copy slicing. PLINQ (Parallel LINQ) is the parallel version of LINQ. Call .AsParallel() to enable:
var results = data.AsParallel().Where(x => x.Valid).Select(x => x.Value);
The query is partitioned across cores and merged at the end. Use for CPU-bound queries on large data sets; gains diminish for small collections due to partitioning overhead.

Question 7 Csharp Programming

What are Concurrent Collections in .NET?

StringBuilder builds a string through repeated appends; the final ToString() allocates a new string.
string.Create(length, state, action) (C# 10+) creates a string with a known final length, filling a backing Span<char> directly. No intermediate buffer.

Use string.Create when you know the exact size of the result — it is the fastest way to format a string in .NET 6+. CancellationToken propagates cancellation requests through async pipelines:

var cts = new CancellationTokenSource();
var token = cts.Token;
await DoWorkAsync(token);
cts.Cancel();

Cooperative methods periodically check token.IsCancellationRequested or call token.ThrowIfCancellationRequested(), which throws OperationCanceledException. Concurrent collections live in System.Collections.Concurrent and are designed for thread-safe access without external locking:

ConcurrentDictionary<TKey, TValue>
ConcurrentQueue<T>
ConcurrentStack<T>
ConcurrentBag<T>
BlockingCollection<T>

They use lock-free and fine-grained locking internally for high scalability. Span<T> (System.Memory) is a ref struct representing a contiguous region of memory — an array, a slice of a string, or stack-allocated memory. It enables zero-allocation slicing and parsing.
Because it is a ref struct, it cannot be boxed, stored on the heap, or used as an async method parameter. Use ReadOnlySpan<T> for read-only access.

Question 8 Csharp Programming

What are the access modifiers in C#?

public — accessible everywhere
private — only within the containing type
protected — within the type and derived types
internal — within the same assembly
protected internal — within the same assembly or derived types
private protected — within the same assembly and derived types (C# 7.2+)
file — within the same source file (C# 11)

Default for top-level types is internal; default for members is private. TPL (System.Threading.Tasks) is the framework for parallel and asynchronous programming in .NET. It centers on the Task type and the Parallel class. Under the hood it uses the thread pool and work-stealing queues for efficient CPU utilization. TPL is the foundation for async/await, Parallel.For, and PLINQ. IEquatable<T> defines bool Equals(T other) for type-safe, allocation-free equality:

struct Point : IEquatable<Point> {
  public bool Equals(Point p) => X == p.X && Y == p.Y;
}

Implement it on value types and on custom types that define value equality. Dictionary and HashSet use it (via EqualityComparer<T>.Default) to avoid boxing.

JIT (Just-In-Time) compiles IL to native code at runtime, on demand, with knowledge of the actual machine. Default for .NET.
AOT (Ahead-Of-Time) compiles to native code at build time, producing a single-file, platform-specific binary with no JIT. Faster startup, smaller memory, but no runtime code generation or dynamic loading.

AOT is great for serverless, CLI tools, and mobile (iOS).

Question 9 Csharp Programming

What is the IAsyncDisposable interface?

A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field.
public string Name { get; set; }
Properties use get and set accessors and are preferred over public fields for encapsulation. A delegate is a type-safe function pointer that holds a reference to a method with a specific signature.

delegate int MathOp(int a, int b);
MathOp add = (a, b) => a + b;

Delegates are the foundation for events and callbacks. Raw string literals allow multi-line strings without escaping quotes or special characters. Use three or more double quotes to delimit:

var json = """
  {"name": "Alice", "age": 30}
""";

The number of closing quotes must match or exceed the opening count, allowing embedded " freely. IAsyncDisposable (.NET Core 3.0+) is the async counterpart of IDisposable:
public async ValueTask DisposeAsync() { await FlushAsync(); }
Use it when cleanup involves async I/O (flushing buffers, closing network connections). The await using statement disposes asynchronously. Many types implement both — the runtime calls DisposeAsync when used with await using.

Question 10 Csharp Programming

What are partial classes in C#?

Explicit implementation implements an interface member without making it public on the class:

class Printer : IPrintable {
  void IPrintable.Print() { ... }
}

The member is only accessible through the interface reference, useful for resolving naming conflicts between multiple interfaces. The partial keyword allows a class (or struct, interface, or record) to be split across multiple files:

public partial class User { ... } // in User.cs
public partial class User { ... } // in User.Queries.cs

All parts are merged at compile time. Common in code generation (WinForms designer, EF), large feature files, and separating hand-written from generated code. All parts must use the same access modifier and base classes. WeakReference allows you to hold a reference to an object without preventing GC:

var weak = new WeakReference(obj);
if (weak.TryGetTarget(out var t)) { ... }

Used in caches, listeners, and to break reference cycles. The GC can collect the object at any time, so always check TryGetTarget before use. WeakReference<T> is the type-safe variant. Async streams (C# 8) allow await foreach over an IAsyncEnumerable<T>:

async IAsyncEnumerable<int> Stream() {
  while (true) yield return await GetNextAsync();
}

Use it to expose data that arrives over time (network chunks, event batches) without buffering it all. Pair with WithCancellation to honor cancellation tokens.

Question 11 Csharp Programming

What is pattern matching in C#?

throw; — re-throws the original exception, preserving the stack trace.
throw ex; — throws the same exception object but resets the stack trace to the current line, losing the original call site information.

Always use bare throw; in catch blocks unless you intentionally want to obscure the origin (rare). Pattern matching tests a value against a pattern and extracts information. Common forms:

Type pattern: if (obj is string s)
Constant pattern: if (x is 42)
Property pattern: if (p is { Age: > 18 })

Used extensively in switch expressions. IEquatable<T> defines bool Equals(T other) for type-safe, allocation-free equality:

struct Point : IEquatable<Point> {
  public bool Equals(Point p) => X == p.X && Y == p.Y;
}

Implement it on value types and on custom types that define value equality. Dictionary and HashSet use it (via EqualityComparer<T>.Default) to avoid boxing. init accessors allow properties to be set only during object initialization:
public string Name { get; init; }
After construction, the property is effectively immutable. This is the modern alternative to read-only fields for init-only DTOs and is supported in object initializers and with expressions.

Question 12 Csharp Programming

What is the difference between ToList and ToArray?

A static constructor initializes a class's static members. It runs once per type, before the first instance is created or any static member is accessed:

class Config {
  static Config() => LoadSettings();
}

It takes no parameters and cannot be called directly. Exceptions thrown here cause TypeInitializationException on every subsequent use of the type. .NET 6+ ships throw helpers to reduce boilerplate validation:

ArgumentNullException.ThrowIfNull(arg)
ArgumentException.ThrowIfNullOrEmpty(arg)
ArgumentException.ThrowIfNullOrWhiteSpace(arg)

Pass paramName: and message: as needed. Prefer them over hand-rolled if (x == null) throw ....

ToList returns a List<T> — mutable, dynamically resizable, supports Add/Remove.
ToArray returns a T[] — fixed size, lower overhead, immutable from the caller's perspective.

Both are O(n) and force enumeration. Prefer ToArray if you need an immutable snapshot; prefer ToList if you need to grow.

Checked arithmetic throws OverflowException on integer overflow.
Unchecked (the default) silently wraps around.

Use the checked block or checked() expression to opt in:
int x = checked(a + b);
Project-wide setting via <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow> in the csproj.

Question 13 Csharp Programming

What is the difference between StringComparer.Ordinal and StringComparer.InvariantCulture?

You can redefine operators on custom types:

struct Complex {
  public static Complex operator +(Complex a, Complex b) => ...
}

Supported operators include arithmetic (+, -, *), comparison (==, !=, <), and some conversions. The operator must be public static. Overloading == requires also overloading !=, and ideally Equals and GetHashCode. GroupBy groups elements by a key:
var groups = students.GroupBy(s => s.Grade);
Each group implements IGrouping<TKey, TElement> with a Key property and a collection of elements.

StringComparer.Ordinal — compares code points, fast, culture-independent.
StringComparer.InvariantCulture — applies invariant culture collation rules, slower, but linguistically consistent across machines.

For dictionaries/hashtables of identifiers, headers, paths: Ordinal. For user-visible sorting and display: InvariantCulture (or CurrentCulture if the result is for the current user only). LINQ (Language Integrated Query) is a set of features that allows you to write query expressions directly in C# to filter, sort, and transform data from collections, databases, and XML.
var results = list.Where(x => x > 5).OrderBy(x => x);

Question 14 Csharp Programming

How do you deconstruct a tuple in C#?

For classes holding unmanaged resources, implement IDisposable and follow the dispose pattern:

public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); }
protected virtual void Dispose(bool disposing) { /* free unmanaged; if (disposing) free managed */ }
~MyClass() { Dispose(disposing: false); }

Callers use using; finalizer is a safety net. The modern alternative is to avoid finalizers by using SafeHandle. ThreadLocal<T> and AsyncLocal<T> give you per-context state:

ThreadLocal<T> — value is unique per OS thread. Bad with async (continuations can run on different threads).
AsyncLocal<T> — value flows with the async control flow. Used for HttpContext, CallContext, ambient context.

Use AsyncLocal for ambient values in async code. WeakReference allows you to hold a reference to an object without preventing GC:

var weak = new WeakReference(obj);
if (weak.TryGetTarget(out var t)) { ... }

Used in caches, listeners, and to break reference cycles. The GC can collect the object at any time, so always check TryGetTarget before use. WeakReference<T> is the type-safe variant. Deconstruction assigns tuple elements to individual variables:
var (name, age) = GetPerson();
You can also deconstruct custom types by implementing a Deconstruct method:
public void Deconstruct(out string name, out int age) { ... }

Question 15 Csharp Programming

What is the System.Text.Json source generator?

The JsonSerializer source generator emits the serialization code at compile time, eliminating reflection:

[JsonSerializable(typeof(MyDto))]
partial class AppContext : JsonSerializerContext { }

Benefits: faster startup, smaller binary, AOT-friendly, trimmed apps work. It is the recommended serializer for new .NET projects over Newtonsoft.Json. The with expression creates a copy of a record with some properties changed (non-destructive mutation):

var p1 = new Person("Alice", 30);
var p2 = p1 with { Age = 31 };

p1 remains unchanged; p2 is a new instance with Age = 31. .NET 6+ ships throw helpers to reduce boilerplate validation:

ArgumentNullException.ThrowIfNull(arg)
ArgumentException.ThrowIfNullOrEmpty(arg)
ArgumentException.ThrowIfNullOrWhiteSpace(arg)

Pass paramName: and message: as needed. Prefer them over hand-rolled if (x == null) throw .... Task.WhenAll awaits multiple tasks concurrently and returns when all complete:
await Task.WhenAll(task1, task2, task3);
If any task faults, the resulting task contains the exception(s). All tasks start effectively in parallel. Use it for fan-out / fan-in patterns where independent I/O operations can run simultaneously.

Question 16 Csharp Programming

What are ref locals and ref returns in C#?

Ref locals store a reference to a variable:
ref int r = ref array[i];
Ref returns allow a method to return a reference rather than a value:
public ref int Find(int[] arr, int idx) => ref arr[idx];
These features enable in-place modification of struct fields inside arrays and span-like behavior, with no defensive copies. IAsyncDisposable (.NET Core 3.0+) is the async counterpart of IDisposable:
public async ValueTask DisposeAsync() { await FlushAsync(); }
Use it when cleanup involves async I/O (flushing buffers, closing network connections). The await using statement disposes asynchronously. Many types implement both — the runtime calls DisposeAsync when used with await using. List patterns match sequences against a pattern:

var s = numbers switch {
  [1, 2, ..] => "starts with 1, 2",
  [_, _, _] => "exactly 3 elements",
  [] => "empty",
  _ => "other"
};

The .. slice pattern matches zero or more elements. Pairs well with Span<T> and arrays for parsing. .NET 6+ ships throw helpers to reduce boilerplate validation:

ArgumentNullException.ThrowIfNull(arg)
ArgumentException.ThrowIfNullOrEmpty(arg)
ArgumentException.ThrowIfNullOrWhiteSpace(arg)

Pass paramName: and message: as needed. Prefer them over hand-rolled if (x == null) throw ....

Question 17 Csharp Programming

What is the C# 9 init-only property?

Span<T> (System.Memory) is a ref struct representing a contiguous region of memory — an array, a slice of a string, or stack-allocated memory. It enables zero-allocation slicing and parsing.
Because it is a ref struct, it cannot be boxed, stored on the heap, or used as an async method parameter. Use ReadOnlySpan<T> for read-only access. init accessors allow properties to be set only during object initialization:
public string Name { get; init; }
After construction, the property is effectively immutable. This is the modern alternative to read-only fields for init-only DTOs and is supported in object initializers and with expressions.

IEnumerable<T> – executes queries in memory (LINQ to Objects). Filtering happens client-side.
IQueryable<T> – builds expression trees that are translated to a query language (e.g., SQL) and executed server-side.

Use IQueryable with databases for performance; IEnumerable for in-memory collections. C# 10 introduced global usings — a single global using applies to every file in the project:
global using System.Linq;
Common in .NET 6+ projects that auto-emit common ones (System, System.Collections.Generic, System.IO, System.Linq, System.Net.Http, System.Threading, etc.).

Question 18 Csharp Programming

What is a ref struct in C#?

Async streams (C# 8) allow await foreach over an IAsyncEnumerable<T>:

async IAsyncEnumerable<int> Stream() {
  while (true) yield return await GetNextAsync();
}

Use it to expose data that arrives over time (network chunks, event batches) without buffering it all. Pair with WithCancellation to honor cancellation tokens. ThreadLocal<T> and AsyncLocal<T> give you per-context state:

ThreadLocal<T> — value is unique per OS thread. Bad with async (continuations can run on different threads).
AsyncLocal<T> — value flows with the async control flow. Used for HttpContext, CallContext, ambient context.

Use AsyncLocal for ambient values in async code. A ref struct (C# 7.2+) is a struct with the ref modifier that guarantees the type can only live on the stack:
public ref struct ReadOnlySpan<T> { ... }
Constraints: it cannot be a field of a non-ref struct, cannot be in an async method, cannot be boxed, cannot be a type argument. This allows safe use of stack-allocated memory without exposing it to the GC. params lets a method accept a variable number of arguments:

int Sum(params int[] numbers) { ... }
Sum(1, 2, 3, 4);

The compiler packs the arguments into an array. Only one params parameter is allowed, and it must be the last parameter. params Span<T> and params ReadOnlySpan<T> are zero-allocation alternatives (C# 13's params collections also allow List<T>, arrays, etc.).

Question 19 Csharp Programming

What is the difference between Task and Task<T>?

GroupBy groups elements by a key:
var groups = students.GroupBy(s => s.Grade);
Each group implements IGrouping<TKey, TElement> with a Key property and a collection of elements.

Task represents an asynchronous operation that does not return a value (like void).
Task<T> represents an asynchronous operation that returns a value of type T.

Use Task for fire-and-forget style async methods and Task<T> when you need a result. Deferred execution means a LINQ query is not executed when defined, but only when the results are enumerated (e.g., via foreach, ToList(), or Count()). This allows efficient chaining of operations. Aggregate applies an accumulator function over a sequence (similar to reduce/fold):
int sum = numbers.Aggregate((acc, x) => acc + x);
With seed:
string csv = names.Aggregate("", (acc, n) => acc == "" ? n : $"{acc},{n}");
Useful for custom accumulation logic beyond Sum/Count.

Question 20 Csharp Programming

What are local functions in C#?

Polymorphism lets a derived class be treated as its base type. Subtype polymorphism is enabled by virtual/override methods, so the actual runtime type determines which method runs:

Animal a = new Dog();
a.Speak(); // "Woof" if Speak is virtual+overridden

Without virtual, the base implementation runs even for derived instances. C# also has parametric polymorphism (generics) and ad-hoc polymorphism (overloads / operator overloading). Generics allow you to define classes, methods, and interfaces with type parameters, enabling code reuse while maintaining type safety.
List<int> numbers = new List<int>();
Generics eliminate boxing/unboxing overhead and catch type errors at compile time. Local functions are methods declared inside another method:

void Outer() {
  int Inner(int x) => x * 2;
  Console.WriteLine(Inner(5));
}

They capture variables from the enclosing scope. Unlike lambdas, they can be static (no capture, no closure allocation), generic, and async. They are emitted as real methods, not delegates. Top-level statements let you write Program.cs without the boilerplate class Program { static void Main() { ... } }:

// Program.cs
Console.WriteLine("Hello!");

Behind the scenes, the compiler synthesizes a Main. Only one file in a project can have top-level statements. Combined with global usings, this makes tiny apps and demos very compact.

Question 21 Csharp Programming

What is the difference between JIT and AOT compilation?

JIT (Just-In-Time) compiles IL to native code at runtime, on demand, with knowledge of the actual machine. Default for .NET.
AOT (Ahead-Of-Time) compiles to native code at build time, producing a single-file, platform-specific binary with no JIT. Faster startup, smaller memory, but no runtime code generation or dynamic loading.

AOT is great for serverless, CLI tools, and mobile (iOS). The standard pattern uses EventHandler<TEventArgs>:

public event EventHandler<MyEventArgs> OnAction;

protected virtual void RaiseAction(MyEventArgs e) {
  OnAction?.Invoke(this, e);
}

MyEventArgs should derive from EventArgs. List patterns match sequences against a pattern:

var s = numbers switch {
  [1, 2, ..] => "starts with 1, 2",
  [_, _, _] => "exactly 3 elements",
  [] => "empty",
  _ => "other"
};

The .. slice pattern matches zero or more elements. Pairs well with Span<T> and arrays for parsing. TPL (System.Threading.Tasks) is the framework for parallel and asynchronous programming in .NET. It centers on the Task type and the Parallel class. Under the hood it uses the thread pool and work-stealing queues for efficient CPU utilization. TPL is the foundation for async/await, Parallel.For, and PLINQ.

Question 22 Csharp Programming

What is lazy initialization in C#?

internal — accessible anywhere in the same assembly.
protected internal — accessible in the same assembly OR in any derived class (even in other assemblies). It is a union of protected and internal.
private protected — accessible only in the same assembly AND in derived types. It is an intersection of protected and internal.

Lazy<T> defers creation of a value until first access, in a thread-safe way:

var lazy = new Lazy<Expensive>(() => new Expensive());
var v = lazy.Value; // constructed on first access

Use Lazy<T> for expensive objects, singletons, or breaking initialization cycles. Variants: LazyThreadSafetyMode.ExecutionAndPublication (default), PublicationOnly, None.

ref passes by reference; the argument must be initialized before the call, and the method may read and write it.
out passes by reference; the argument need not be initialized, but the method must assign it before returning.
in passes by readonly reference — the method cannot modify the argument; avoids a copy for large structs.

record (or record class) is a reference type allocated on the heap.
record struct (C# 10+) is a value type allocated on the stack.

Both provide value-based equality and with expressions, but differ in memory allocation and copy semantics.

Question 23 Csharp Programming

What are Action and Func delegates?

Action – a delegate that returns void. E.g., Action<string> log = msg => Console.WriteLine(msg);
Func – a delegate that returns a value. The last type parameter is the return type. E.g., Func<int, int, int> add = (a, b) => a + b;

The standard pattern uses EventHandler<TEventArgs>:

public event EventHandler<MyEventArgs> OnAction;

protected virtual void RaiseAction(MyEventArgs e) {
  OnAction?.Invoke(this, e);
}

MyEventArgs should derive from EventArgs. The partial keyword allows a class (or struct, interface, or record) to be split across multiple files:

public partial class User { ... } // in User.cs
public partial class User { ... } // in User.Queries.cs

All parts are merged at compile time. Common in code generation (WinForms designer, EF), large feature files, and separating hand-written from generated code. All parts must use the same access modifier and base classes. Task.WhenAny returns a task that completes when any one of the supplied tasks completes:
var first = await Task.WhenAny(task1, task2, task3);
Common uses: timeouts, racing multiple sources, or implementing cancellation. Often combined with a delay to bound wait time.

Question 24 Csharp Programming

What is the difference between dynamic and object?

DateTime stores a date and time with a Kind of Unspecified, Utc, or Local. The same DateTime can refer to different moments depending on its Kind.
DateTimeOffset stores a date/time plus an explicit offset from UTC, unambiguously identifying a single point in time. Comparison and arithmetic use UTC.

For server-side code, time-zone math, and persistence, prefer DateTimeOffset to avoid Kind-related bugs. C# 10 introduced global usings — a single global using applies to every file in the project:
global using System.Linq;
Common in .NET 6+ projects that auto-emit common ones (System, System.Collections.Generic, System.IO, System.Linq, System.Net.Http, System.Threading, etc.).

object is statically typed; the compiler enforces member access (you'd need to cast to call members).
dynamic bypasses compile-time checks; member calls are resolved at runtime via the DLR (Dynamic Language Runtime), using IDynamicMetaObjectProvider or ExpandoObject.

Use dynamic sparingly — for COM interop, dynamic JSON, or interop with dynamic languages.

ToList returns a List<T> — mutable, dynamically resizable, supports Add/Remove.
ToArray returns a T[] — fixed size, lower overhead, immutable from the caller's perspective.

Both are O(n) and force enumeration. Prefer ToArray if you need an immutable snapshot; prefer ToList if you need to grow.

Question 25 Csharp Programming

What is the Task Parallel Library (TPL)?

ToList returns a List<T> — mutable, dynamically resizable, supports Add/Remove.
ToArray returns a T[] — fixed size, lower overhead, immutable from the caller's perspective.

Both are O(n) and force enumeration. Prefer ToArray if you need an immutable snapshot; prefer ToList if you need to grow. TPL (System.Threading.Tasks) is the framework for parallel and asynchronous programming in .NET. It centers on the Task type and the Parallel class. Under the hood it uses the thread pool and work-stealing queues for efficient CPU utilization. TPL is the foundation for async/await, Parallel.For, and PLINQ. .NET 6+ ships throw helpers to reduce boilerplate validation:

ArgumentNullException.ThrowIfNull(arg)
ArgumentException.ThrowIfNullOrEmpty(arg)
ArgumentException.ThrowIfNullOrWhiteSpace(arg)

Pass paramName: and message: as needed. Prefer them over hand-rolled if (x == null) throw ....

Two struct instances with the same field values are value-equal. Equals checks fields (or your override).
Two class instances with the same field values are not value-equal by default — Equals uses reference equality unless overridden (or unless the type is a record).

Use record or override Equals/GetHashCode on classes that should compare by value.

Question 26 Csharp Programming

What is yield return in C#?

A shallow copy duplicates the top-level object but shares references to nested objects.
A deep copy recursively duplicates everything, so the clone is fully independent.

MemberwiseClone() makes a shallow copy. record's with expression does a shallow copy. Use serialization, copy constructors, or libraries (e.g., JsonSerializer) for deep copies.

Zip(a, b, (x, y) => ...) — pairs elements by position. Stops at the shorter sequence.
a.Join(b, x => x.Key, y => y.Key, (x, y) => ...) — pairs by a key. Like SQL INNER JOIN.

Use Zip for parallel arrays; use Join for relational merges.

where T : new() — the type argument must expose a public parameterless constructor. The compiler can then new T() inside the generic.
where T : class — the type argument must be a reference type; no constructor is required.

You can combine them: where T : class, new(). yield return lets an iterator method produce values one at a time, lazily:

IEnumerable<int> Range(int n) {
  for (int i = 0; i < n; i++) yield return i;
}

The compiler generates a state machine. yield break terminates the iterator early. Each call to GetEnumerator() returns a fresh enumerator.

Question 27 Csharp Programming

What is the ICloneable interface and why is it controversial?

ICloneable declares object Clone(), but the contract does not specify whether it returns a shallow or deep copy — implementations vary. It is widely considered a design mistake; modern APIs avoid it and define explicit copy methods (e.g., CopyTo) or rely on record with-expressions for value-based copies. Task.WhenAny returns a task that completes when any one of the supplied tasks completes:
var first = await Task.WhenAny(task1, task2, task3);
Common uses: timeouts, racing multiple sources, or implementing cancellation. Often combined with a delay to bound wait time. A multicast delegate holds references to multiple methods. When invoked, all methods in the invocation list are called in order.

Action greet = () => Console.Write("Hi ");
greet += () => Console.Write("there!");
greet(); // outputs: Hi there!

abstract methods have no implementation and must be overridden in derived classes.
virtual methods have a default implementation that derived classes may optionally override.

Both use the override keyword in derived classes.

Question 28 Csharp Programming

What are the C# preprocessor directives?

Zip(a, b, (x, y) => ...) — pairs elements by position. Stops at the shorter sequence.
a.Join(b, x => x.Key, y => y.Key, (x, y) => ...) — pairs by a key. Like SQL INNER JOIN.

Use Zip for parallel arrays; use Join for relational merges. TaskCompletionSource<T> lets you create a Task<T> you can manually complete, fail, or cancel from non-async code:

var tcs = new TaskCompletionSource<int>();
// later...
tcs.SetResult(42);

Use it to wrap callback-based APIs (events, IAsyncResult patterns) into awaitable tasks without an async method.

#define / #undef — define/undefine a symbol
#if / #elif / #else / #endif — conditional compilation
#nullable enable / #nullable disable / #nullable restore — nullable annotation context
#region / #endregion — collapsible editor regions
#pragma warning disable / #pragma warning restore — suppress compiler warnings
#line — adjust line numbers in error messages
#error / #warning — emit a compile error or warning

Note: preprocessor directives are processed by the C# compiler — the underlying language has no preprocessor.

A delegate can be invoked by any code that has access to it.
An event wraps a delegate and restricts invocation to the declaring class only; external code can only subscribe or unsubscribe.

Events provide better encapsulation for the publisher-subscriber pattern.

Question 29 Csharp Programming

What is an extension method in C#?

String interpolation embeds expressions directly into a string using the $ prefix and { } placeholders:
var s = $"Hello, {name}! You are {age} years old.";
Introduced in C# 6. The compiler converts this into a string.Format or DefaultInterpolatedStringHandler call (C# 10+). Use {{ and }} to escape literal braces. An extension method adds new methods to existing types without modifying them. It must be a static method in a static class, with this before the first parameter:

public static class StringExt {
  public static bool IsEmpty(this string s) => string.IsNullOrEmpty(s);
}

An auto-implemented property lets the compiler generate the backing field automatically:
public int Age { get; set; }
You can also set access levels: public string Name { get; private set; }
Use init for immutable initialization: public string Id { get; init; }

Ordinal compares raw Unicode code units — fast, culture-independent, deterministic. Best for internal data, file paths, and security checks.
CurrentCulture uses the current culture's collation rules — appropriate for user-visible text like sorted lists.

Use OrdinalIgnoreCase for case-insensitive matching of internal identifiers.

Question 30 Csharp Programming

What is the difference between async void and async Task?

async Task is the standard: the returned task can be awaited, exceptions are captured and surfaced.
async void has no task to await; exceptions go directly to the synchronization context (or crash the process in console apps).

Use async void only for top-level event handlers (UI button clicks). Avoid it in library methods — call sites cannot try/catch properly. Exceptions in async methods are captured in the returned Task. Use try/catch with await:

try {
  await SomeAsyncMethod();
} catch (HttpRequestException ex) {
  Console.WriteLine(ex.Message);
}

Without await, the exception goes unobserved unless the task is inspected. Generic constraints restrict the types that can be used as type arguments:

where T : class – reference type
where T : struct – value type
where T : new() – parameterless constructor
where T : IComparable – implements interface
where T : BaseClass – derives from class

ExceptionDispatchInfo.Throw(ex) rethrows an exception preserving the original stack trace, even across threads or async boundaries:
ExceptionDispatchInfo.Capture(ex).Throw();
Useful when capturing an exception in one task and rethrowing it after awaiting, where the original stack trace would otherwise be lost.

Question 31 Csharp Programming

What is a record class positional vs record struct?

Cast<T> — casts every element to T; throws InvalidCastException on the first non-T element.
OfType<T> — keeps only elements that are T, skipping the rest.

Use OfType when filtering a non-generic collection (ArrayList, IEnumerable from a legacy API) for items of a specific type. In .NET, memory leaks are not about forgetting to free memory (the GC does that) — they are about references that the GC cannot see as unreachable:

Static fields holding object graphs
Event handlers not unsubscribed
Unbounded caches
Captured closures in long-lived objects
IDisposable not disposed (especially with unmanaged resources)

Diagnose with dotMemory, PerfView, or GC.GetTotalMemory(true).

A shallow copy duplicates the top-level object but shares references to nested objects.
A deep copy recursively duplicates everything, so the clone is fully independent.

MemberwiseClone() makes a shallow copy. record's with expression does a shallow copy. Use serialization, copy constructors, or libraries (e.g., JsonSerializer) for deep copies.

public record Person(string Name, int Age); — positional record on a reference type. Immutable by default, value equality.
public readonly record struct Point(int X, int Y); — positional record on a value type. Stack-allocated, no allocation, value equality.

Use the readonly modifier on record struct to prevent defensive copies.

Question 32 Csharp Programming

What is the difference between sealed class and static class?

A multicast delegate holds references to multiple methods. When invoked, all methods in the invocation list are called in order.

Action greet = () => Console.Write("Hi ");
greet += () => Console.Write("there!");
greet(); // outputs: Hi there!

Top-level statements let you write Program.cs without the boilerplate class Program { static void Main() { ... } }:

// Program.cs
Console.WriteLine("Hello!");

Behind the scenes, the compiler synthesizes a Main. Only one file in a project can have top-level statements. Combined with global usings, this makes tiny apps and demos very compact. volatile tells the compiler/JIT that a field may be modified by multiple threads, preventing reordering or caching of reads/writes:
private volatile bool _stopped;
Reads acquire a memory barrier; writes release one. volatile is limited to reference types, pointer types, byte, short, int, char, float, and enum types with those underlying types.

sealed class — can be instantiated, but cannot be inherited. Fields, instance methods, and constructors are allowed.
static class — cannot be instantiated or inherited. Only static members are allowed. Implicitly sealed and abstract.

Use static for utility namespaces; use sealed to lock down a regular class that should not be derived from.

Question 33 Csharp Programming

What is the difference between Convert.ToInt32 and (int)?

Convert.ToInt32(d) rounds double values using banker's rounding (to even).
(int)d on a double truncates toward zero.

Also, Convert.ToInt32(null) returns 0, while (int)null won't compile. Use Convert for cross-type safe conversions. Boxing wraps a value type (e.g., int) in an object, copying it to the heap:
object o = 42;
Unboxing extracts the value, requiring an explicit cast and a type match:
int n = (int)o;
Boxing and unboxing are expensive operations — avoid in hot paths. Generics (List<T>) eliminate the need for boxing. GroupBy groups elements by a key:
var groups = students.GroupBy(s => s.Grade);
Each group implements IGrouping<TKey, TElement> with a Key property and a collection of elements.

Two struct instances with the same field values are value-equal. Equals checks fields (or your override).
Two class instances with the same field values are not value-equal by default — Equals uses reference equality unless overridden (or unless the type is a record).

Use record or override Equals/GetHashCode on classes that should compare by value.

Question 34 Csharp Programming

What is the difference between Array.Length and Array.Count()?

List<T> is an ordered, indexable sequence. Contains is O(n).
HashSet<T> is an unordered collection of unique items with O(1) Contains, Add, Remove.

Use HashSet for membership tests and deduplication; use List when order and indexing matter.

arr.Length is a property on arrays; O(1).
arr.Count() is a LINQ extension method that walks the sequence and returns the count — O(n) for arrays, O(1) for ICollection via the Count property.

Prefer .Length for arrays; prefer .Count on IEnumerable<T> when you don't know the concrete type. IAsyncDisposable (.NET Core 3.0+) is the async counterpart of IDisposable:
public async ValueTask DisposeAsync() { await FlushAsync(); }
Use it when cleanup involves async I/O (flushing buffers, closing network connections). The await using statement disposes asynchronously. Many types implement both — the runtime calls DisposeAsync when used with await using.

abstract methods have no implementation and must be overridden in derived classes.
virtual methods have a default implementation that derived classes may optionally override.

Both use the override keyword in derived classes.

Question 35 Csharp Programming

What is the difference between Array and List<T>?

An abstract class cannot be instantiated and may contain both abstract and concrete members:

public abstract class Shape {
  public abstract double Area();
  public void Describe() => Console.WriteLine($"Area: {Area()}");
}

Derived classes must implement all abstract members.

Array (e.g., int[]) — fixed size, allocated in one block, very low overhead. Slicing requires Array.Copy or Span<T>.
List<T> — dynamically resizable, backed by an array that doubles when full. Add is amortized O(1); Insert/RemoveAt are O(n).

Use arrays for fixed-size, hot-path data; use List<T> when you need to grow/shrink.

Mutex — single-owner lock, can be named and cross-process. Used to ensure only one instance of an app runs.
SemaphoreSlim — in-process, allows N concurrent holders. Lightweight.

For cross-process coordination, use Mutex or Semaphore (the full-fat version). For in-process, prefer SemaphoreSlim. .NET 6+ ships throw helpers to reduce boilerplate validation:

ArgumentNullException.ThrowIfNull(arg)
ArgumentException.ThrowIfNullOrEmpty(arg)
ArgumentException.ThrowIfNullOrWhiteSpace(arg)

Pass paramName: and message: as needed. Prefer them over hand-rolled if (x == null) throw ....

Question 36 Csharp Programming

What is an auto-implemented property?

IAsyncDisposable (.NET Core 3.0+) is the async counterpart of IDisposable:
public async ValueTask DisposeAsync() { await FlushAsync(); }
Use it when cleanup involves async I/O (flushing buffers, closing network connections). The await using statement disposes asynchronously. Many types implement both — the runtime calls DisposeAsync when used with await using. throw can now appear in expressions, not just statements:
var name = dict.TryGetValue(id, out var v) ? v : throw new KeyNotFoundException(id);
Useful in conditional operators, switch expressions, expression-bodied members, and null-coalescing:
name = input ?? throw new ArgumentNullException(nameof(input));

List<T> is an ordered, indexable sequence. Contains is O(n).
HashSet<T> is an unordered collection of unique items with O(1) Contains, Add, Remove.

Use HashSet for membership tests and deduplication; use List when order and indexing matter. An auto-implemented property lets the compiler generate the backing field automatically:
public int Age { get; set; }
You can also set access levels: public string Name { get; private set; }
Use init for immutable initialization: public string Id { get; init; }

Question 37 Csharp Programming

What is the IDisposable interface and using statement?

Nullable value types allow value types to represent null:
int? age = null;
This is shorthand for Nullable<int>. Key members:

.HasValue – returns true if not null
.Value – returns the value (throws if null)

IDisposable provides a Dispose() method for releasing unmanaged resources.
The using statement ensures Dispose is called automatically:

using var reader = new StreamReader(path);
string text = reader.ReadToEnd();

Equivalent to a try/finally block calling Dispose. volatile tells the compiler/JIT that a field may be modified by multiple threads, preventing reordering or caching of reads/writes:
private volatile bool _stopped;
Reads acquire a memory barrier; writes release one. volatile is limited to reference types, pointer types, byte, short, int, char, float, and enum types with those underlying types. Concurrent collections live in System.Collections.Concurrent and are designed for thread-safe access without external locking:

ConcurrentDictionary<TKey, TValue>
ConcurrentQueue<T>
ConcurrentStack<T>
ConcurrentBag<T>
BlockingCollection<T>

They use lock-free and fine-grained locking internally for high scalability.

Question 38 Csharp Programming

What is the difference between IComparable and IComparer?

List<T> is an ordered, indexable sequence. Contains is O(n).
HashSet<T> is an unordered collection of unique items with O(1) Contains, Add, Remove.

Use HashSet for membership tests and deduplication; use List when order and indexing matter. Pattern matching tests a value against a pattern and extracts information. Common forms:

Type pattern: if (obj is string s)
Constant pattern: if (x is 42)
Property pattern: if (p is { Age: > 18 })

Used extensively in switch expressions.

IComparable<T> defines the natural order on the type itself (CompareTo(T other)).
IComparer<T> is a separate object that defines an alternative ordering (Compare(T a, T b)).

Use IComparable for the default sort; pass an IComparer to List.Sort or OrderBy for different orderings. async/await is a language feature for writing asynchronous code that looks synchronous.

async Task<string> FetchAsync() {
  var data = await httpClient.GetStringAsync(url);
  return data;
}

It frees the calling thread while awaiting I/O operations.

Question 39 Csharp Programming

What is the difference between is and as operators?

Dictionary<TKey, TValue> provides O(1) average-case lookup, insertion, and deletion using a hash table. Worst case is O(n) when many keys hash to the same bucket, but this is rare with a good hash. TryGetValue is preferred over ContainsKey + indexer to avoid double-hashing. Iteration order is not guaranteed (use SortedDictionary for order).

is tests whether an object is of a given type: if (obj is string s). It returns bool and (with the pattern form) can extract the value.
as attempts a safe cast: var s = obj as string;. It returns null on failure (for reference types and nullable value types) instead of throwing InvalidCastException.

Use is for branching; use as when a null result is acceptable.

JIT (Just-In-Time) compiles IL to native code at runtime, on demand, with knowledge of the actual machine. Default for .NET.
AOT (Ahead-Of-Time) compiles to native code at build time, producing a single-file, platform-specific binary with no JIT. Faster startup, smaller memory, but no runtime code generation or dynamic loading.

AOT is great for serverless, CLI tools, and mobile (iOS). throw can now appear in expressions, not just statements:
var name = dict.TryGetValue(id, out var v) ? v : throw new KeyNotFoundException(id);
Useful in conditional operators, switch expressions, expression-bodied members, and null-coalescing:
name = input ?? throw new ArgumentNullException(nameof(input));

Question 40 Csharp Programming

What is Span<T> in C#?

IEnumerable<T> is the base interface for all generic collections that can be enumerated. It requires implementing GetEnumerator().
It enables:

foreach loops
LINQ queries
Deferred execution

Most collection types implement this interface.

is tests whether an object is of a given type: if (obj is string s). It returns bool and (with the pattern form) can extract the value.
as attempts a safe cast: var s = obj as string;. It returns null on failure (for reference types and nullable value types) instead of throwing InvalidCastException.

Use is for branching; use as when a null result is acceptable. The partial keyword allows a class (or struct, interface, or record) to be split across multiple files:

public partial class User { ... } // in User.cs
public partial class User { ... } // in User.Queries.cs

All parts are merged at compile time. Common in code generation (WinForms designer, EF), large feature files, and separating hand-written from generated code. All parts must use the same access modifier and base classes. Span<T> (System.Memory) is a ref struct representing a contiguous region of memory — an array, a slice of a string, or stack-allocated memory. It enables zero-allocation slicing and parsing.
Because it is a ref struct, it cannot be boxed, stored on the heap, or used as an async method parameter. Use ReadOnlySpan<T> for read-only access.

Question 41 Csharp Programming

What are static constructors in C#?

Exceptions in async methods are captured in the returned Task. Use try/catch with await:

try {
  await SomeAsyncMethod();
} catch (HttpRequestException ex) {
  Console.WriteLine(ex.Message);
}

Without await, the exception goes unobserved unless the task is inspected. A static lambda (static (x, y) => x + y) cannot capture variables from the enclosing scope, so the compiler avoids creating a closure object — a measurable allocation savings in hot paths. C# 9+ allows static on lambdas; C# 12+ allows static on anonymous methods as well. A static constructor initializes a class's static members. It runs once per type, before the first instance is created or any static member is accessed:

class Config {
  static Config() => LoadSettings();
}

It takes no parameters and cannot be called directly. Exceptions thrown here cause TypeInitializationException on every subsequent use of the type. params lets a method accept a variable number of arguments:

int Sum(params int[] numbers) { ... }
Sum(1, 2, 3, 4);

The compiler packs the arguments into an array. Only one params parameter is allowed, and it must be the last parameter. params Span<T> and params ReadOnlySpan<T> are zero-allocation alternatives (C# 13's params collections also allow List<T>, arrays, etc.).

Question 42 Csharp Programming

What is the difference between Zip and Join in LINQ?

Zip(a, b, (x, y) => ...) — pairs elements by position. Stops at the shorter sequence.
a.Join(b, x => x.Key, y => y.Key, (x, y) => ...) — pairs by a key. Like SQL INNER JOIN.

Use Zip for parallel arrays; use Join for relational merges. An indexer allows instances of a class to be indexed like an array:

public T this[int index] {
  get { return items[index]; }
  set { items[index] = value; }
}

You can define indexers with any parameter type, not just int. IEquatable<T> defines bool Equals(T other) for type-safe, allocation-free equality:

struct Point : IEquatable<Point> {
  public bool Equals(Point p) => X == p.X && Y == p.Y;
}

Implement it on value types and on custom types that define value equality. Dictionary and HashSet use it (via EqualityComparer<T>.Default) to avoid boxing. Reflection (System.Reflection) lets you inspect and manipulate types at runtime: get properties, methods, attributes, and invoke them dynamically:

var t = typeof(MyClass);
var props = t.GetProperties();
var inst = Activator.CreateInstance(t);

Powerful but slow and unsafe (no compile-time checks). Common in DI containers, ORMs, and serializers. Prefer Source Generators or expression trees for performance-critical paths.

Question 43 Csharp Programming

What are tuples in C#?

A static constructor initializes a class's static members. It runs once per type, before the first instance is created or any static member is accessed:

class Config {
  static Config() => LoadSettings();
}

It takes no parameters and cannot be called directly. Exceptions thrown here cause TypeInitializationException on every subsequent use of the type. Generic constraints restrict the types that can be used as type arguments:

where T : class – reference type
where T : struct – value type
where T : new() – parameterless constructor
where T : IComparable – implements interface
where T : BaseClass – derives from class

Tuples are lightweight data structures for grouping multiple values:

var point = (X: 3, Y: 4);
Console.WriteLine(point.X);

Method return example:
(string Name, int Age) GetPerson() => ("Alice", 30);
Tuples use ValueTuple (value type) under the hood. IDisposable provides a Dispose() method for releasing unmanaged resources.
The using statement ensures Dispose is called automatically:

using var reader = new StreamReader(path);
string text = reader.ReadToEnd();

Equivalent to a try/finally block calling Dispose.

Question 44 Csharp Programming

What are top-level statements in .NET 6+?

Pattern matching tests a value against a pattern and extracts information. Common forms:

Type pattern: if (obj is string s)
Constant pattern: if (x is 42)
Property pattern: if (p is { Age: > 18 })

Used extensively in switch expressions. Top-level statements let you write Program.cs without the boilerplate class Program { static void Main() { ... } }:

// Program.cs
Console.WriteLine("Hello!");

Behind the scenes, the compiler synthesizes a Main. Only one file in a project can have top-level statements. Combined with global usings, this makes tiny apps and demos very compact.

Dispose is called explicitly by user code (typically via using) — runs deterministically.
Finalize (destructor) is called by the GC at some point after the object becomes unreachable — non-deterministic, expensive (objects survive an extra GC cycle).

Implement Dispose for prompt cleanup. Finalize is a last-resort safety net and should not allocate or reference other managed objects. A struct is a value type allocated on the stack (or inline in a containing type) — not on the heap.
Use structs for:

Small, frequently allocated types
Types that are logically a single value (e.g., DateTime, Guid)
Immutable types

Structs cannot inherit from another struct, but can implement interfaces. Large mutable structs hurt performance due to copy semantics.

Question 45 Csharp Programming

What is the difference between const and readonly?

Two struct instances with the same field values are value-equal. Equals checks fields (or your override).
Two class instances with the same field values are not value-equal by default — Equals uses reference equality unless overridden (or unless the type is a record).

Use record or override Equals/GetHashCode on classes that should compare by value. ICloneable declares object Clone(), but the contract does not specify whether it returns a shallow or deep copy — implementations vary. It is widely considered a design mistake; modern APIs avoid it and define explicit copy methods (e.g., CopyTo) or rely on record with-expressions for value-based copies.

const is a compile-time constant — its value is inlined into every call site. Allowed only for primitive/string types. public const int Max = 100;
readonly is a runtime constant — the value can be set in a constructor. Works for any type, including reference types and structs.

Changing a const in a library requires recompiling all assemblies that reference it; readonly does not. LINQ (Language Integrated Query) is a set of features that allows you to write query expressions directly in C# to filter, sort, and transform data from collections, databases, and XML.
var results = list.Where(x => x > 5).OrderBy(x => x);

Question 46 Csharp Programming

What is the difference between new() constraint and class constraint?

where T : new() — the type argument must expose a public parameterless constructor. The compiler can then new T() inside the generic.
where T : class — the type argument must be a reference type; no constructor is required.

You can combine them: where T : class, new(). Explicit implementation implements an interface member without making it public on the class:

class Printer : IPrintable {
  void IPrintable.Print() { ... }
}

The member is only accessible through the interface reference, useful for resolving naming conflicts between multiple interfaces. IEquatable<T> defines bool Equals(T other) for type-safe, allocation-free equality:

struct Point : IEquatable<Point> {
  public bool Equals(Point p) => X == p.X && Y == p.Y;
}

Implement it on value types and on custom types that define value equality. Dictionary and HashSet use it (via EqualityComparer<T>.Default) to avoid boxing. Generic constraints restrict the types that can be used as type arguments:

where T : class – reference type
where T : struct – value type
where T : new() – parameterless constructor
where T : IComparable – implements interface
where T : BaseClass – derives from class

Question 47 Csharp Programming

What is the difference between Mutex and SemaphoreSlim?

StringBuilder builds a string through repeated appends; the final ToString() allocates a new string.
string.Create(length, state, action) (C# 10+) creates a string with a known final length, filling a backing Span<char> directly. No intermediate buffer.

Use string.Create when you know the exact size of the result — it is the fastest way to format a string in .NET 6+. The with expression creates a copy of a record with some properties changed (non-destructive mutation):

var p1 = new Person("Alice", 30);
var p2 = p1 with { Age = 31 };

p1 remains unchanged; p2 is a new instance with Age = 31.

Mutex — single-owner lock, can be named and cross-process. Used to ensure only one instance of an app runs.
SemaphoreSlim — in-process, allows N concurrent holders. Lightweight.

For cross-process coordination, use Mutex or Semaphore (the full-fat version). For in-process, prefer SemaphoreSlim.

List<T> is an ordered, indexable sequence. Contains is O(n).
HashSet<T> is an unordered collection of unique items with O(1) Contains, Add, Remove.

Use HashSet for membership tests and deduplication; use List when order and indexing matter.

Question 48 Csharp Programming

What is encoding and decoding in C#?

Task.WhenAll awaits multiple tasks concurrently and returns when all complete:
await Task.WhenAll(task1, task2, task3);
If any task faults, the resulting task contains the exception(s). All tasks start effectively in parallel. Use it for fan-out / fan-in patterns where independent I/O operations can run simultaneously. Encoding converts between char sequences (UTF-16) and byte sequences:

Encoding.UTF8.GetBytes(s) — string to bytes
Encoding.UTF8.GetString(bytes) — bytes to string

Always specify the encoding explicitly. Encoding.UTF8 is the safest default. The Encoding.Default is the system's ANSI code page and should be avoided in cross-platform code.

var is statically typed; the compiler infers the type at compile time, and the variable is bound to that type forever.
dynamic bypasses compile-time checks entirely — member calls are resolved at runtime.

var improves readability and gives IntelliSense. dynamic is for interop with dynamic languages or late-bound APIs. C# 9+ supports relational and logical patterns in switch expressions:

string tier = score switch {
  >= 90 => "A",
  >= 80 and < 90 => "B",
  _ => "C"
};

Logical combinators: and, or, not.

Question 49 Csharp Programming

What is a struct in C# and when should you use it?

Lazy<T> defers creation of a value until first access, in a thread-safe way:

var lazy = new Lazy<Expensive>(() => new Expensive());
var v = lazy.Value; // constructed on first access

Use Lazy<T> for expensive objects, singletons, or breaking initialization cycles. Variants: LazyThreadSafetyMode.ExecutionAndPublication (default), PublicationOnly, None. Default interface methods (C# 8+) allow interfaces to provide method implementations:

public interface ILogger {
  void Log(string msg);
  void LogError(string msg) => Log($"ERROR: {msg}");
}

Implementing classes inherit the default but can override it. A struct is a value type allocated on the stack (or inline in a containing type) — not on the heap.
Use structs for:

Small, frequently allocated types
Types that are logically a single value (e.g., DateTime, Guid)
Immutable types

Structs cannot inherit from another struct, but can implement interfaces. Large mutable structs hurt performance due to copy semantics. nameof returns the name of a symbol as a string, with compile-time checking:
ArgumentNullException.ThrowIfNull(arg, nameof(arg));
Renames propagate automatically. Useful in ArgumentException messages, INotifyPropertyChanged callers, and logging. It is evaluated at compile time, so it has zero runtime cost.

Question 50 Csharp Programming

What is a property in C#?

An extension method adds new methods to existing types without modifying them. It must be a static method in a static class, with this before the first parameter:

public static class StringExt {
  public static bool IsEmpty(this string s) => string.IsNullOrEmpty(s);
}

ref passes by reference; the argument must be initialized before the call, and the method may read and write it.
out passes by reference; the argument need not be initialized, but the method must assign it before returning.
in passes by readonly reference — the method cannot modify the argument; avoids a copy for large structs.

Checked arithmetic throws OverflowException on integer overflow.
Unchecked (the default) silently wraps around.

Use the checked block or checked() expression to opt in:
int x = checked(a + b);
Project-wide setting via <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow> in the csproj. A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field.
public string Name { get; set; }
Properties use get and set accessors and are preferred over public fields for encapsulation.