- Value Types: Store data directly (e.g., int, struct), allocated on the stack, copied by value.
- Reference Types: Store a reference to data (e.g., class, string), allocated on the heap, copied by reference.
- Comparison: Value types are faster for small data but immutable; reference types support complex objects but involve garbage collection.
Example:

int a = 10; // Value type
string b = "Hello"; // Reference type
int c = a; // Copy value
string d = b; // Copy reference

Exception handling in C# uses `try`, `catch`, `finally`, and `throw` to handle runtime errors gracefully.
Example:

try {
    int x = 0;
    int y = 10 / x;
} catch (DivideByZeroException ex) {
    Console.WriteLine("Error: " + ex.Message);
} finally {
    Console.WriteLine("Cleanup");
}

Property accessors in C# are the `get` and `set` methods used to read and write a property's value, providing controlled access to a private field.
Example:

class Person {
    private string name;
    public string Name {
        get { return name; }
        set { name = value; }
    }
}

C# is a modern, object-oriented programming language developed by Microsoft, used for building applications on the .NET framework, known for its type safety and versatility.

- break: Exits the loop immediately.
- continue: Skips the current iteration and proceeds to the next.
Example:

for (int i = 0; i < 5; i++) {
    if (i == 2) continue; // Skips 2
    if (i == 4) break;    // Exits at 4
    Console.WriteLine(i);
} // Outputs: 0, 1, 3

An object is an instance of a class, containing data and behavior defined by the class, created at runtime.
Example:

class Dog {
    public string Name { get; set; }
}

Dog dog = new Dog { Name = "Rex" }; // Object

Serialization is the process of converting an object into a stream of bytes for storage or transmission, and deserialization is the reverse.
Example:

[Serializable]
class Person {
    public string Name { get; set; }
}

Partial classes allow a class definition to be split across multiple files, useful for code organization and auto-generated code.
Example:

partial class MyClass {
    public void Method1() { }
}

partial class MyClass {
    public void Method2() { }
}

Generics allow defining classes, methods, or interfaces with a placeholder type, enabling type-safe, reusable code without casting.
Example:

class GenericList {
    public void Add(T item) { }
}

GenericList list = new GenericList();

No, `this` cannot be used in a static method because it refers to the current instance, and static methods are not tied to instances.
Example:

class MyClass {
    static void StaticMethod() {
        // Console.WriteLine(this); // Error
    }
}

No, only the first matching `catch` block is executed for a given exception.
Example:

try {
    throw new Exception();
} catch (ArgumentException) {
    // Not executed
} catch (Exception) {
    // Executed
}

The `finally` block executes regardless of whether an exception occurs, ensuring cleanup tasks like closing resources are performed.
Example:

try {
    // Code that may throw exception
} catch {
    // Handle exception
} finally {
    Console.WriteLine("Always executed");
}

- Concrete: Instantiable classes.
- Abstract: Cannot be instantiated, used as base classes.
- Sealed: Cannot be inherited.
- Static: Contains only static members.
- Partial: Split across multiple files.
Example:

abstract class A { }
sealed class B { }
static class C { }
partial class D { }

- Managed Code: Runs under CLR, with memory management (e.g., C#).
- Unmanaged Code: Runs outside CLR, no automatic memory management (e.g., C++).

- string: Immutable, each modification creates a new object.
- StringBuilder: Mutable, efficient for frequent modifications.
Example:

StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append("World");

Reference types store a reference to data on the heap (e.g., classes, interfaces, arrays, strings).
Example:

string s = "Hello"; // Reference type
object o = new object();

LINQ (Language Integrated Query) is a set of extensions for querying data in C#, supporting collections, databases, XML, etc.
Example:

int[] numbers = { 1, 2, 3, 4 };
var even = from n in numbers where n % 2 == 0 select n;

- Class: Reference type, heap-allocated, supports inheritance.
- Structure: Value type, stack-allocated, no inheritance.
Example:

class MyClass { public int X; }
struct MyStruct { public int X; }

- Boxing: Converting a value type to a reference type (object).
- Unboxing: Converting a reference type back to a value type.
Example:

int i = 123;
object o = i; // Boxing
int j = (int)o; // Unboxing

Same as Q19: Class is reference type, struct is value type; classes support inheritance, structs do not.
Example:

class C { public int X; }
struct S { public int X; }

An abstract class cannot be instantiated and may contain abstract methods (no implementation) and concrete methods, used as a base class.
Example:

abstract class Shape {
    public abstract void Draw();
}

A namespace organizes code into logical groups to avoid naming conflicts and improve readability.
Example:

namespace MyApp {
    class MyClass { }
}

- Value: Copy of the value.
- Reference (ref): Reference to the variable.
- Output (out): For returning values.
- Params: Variable number of arguments.
Example:

void Method(int a, ref int b, out int c, params int[] d) {
    c = 0;
}

Nullable types allow value types to represent `null`, using the `?` operator or `Nullable`.
Example:

int? x = null;
Nullable y = null;

An enum is a value type defining a set of named constants, typically used for fixed values.
Example:

enum Days { Monday, Tuesday, Wednesday }

Yes, use a single `catch` block with a base exception type or C# 6.0+ exception filters to handle multiple exceptions.
Example:

try {
    // Code
} catch (Exception ex) when (ex is ArgumentNullException || ex is InvalidOperationException) {
    // Handle
}

- Assignment: Copies the reference (same object).
- Shallow Copy: Copies top-level fields, references remain shared.
- Deep Copy: Copies all fields and nested objects.
Example:

record Person(string Name);
Person p1 = new Person("Alice");
Person p2 = p1; // Assignment
Person p3 = p1 with { }; // Deep copy

Dynamic type variables (`dynamic`) bypass compile-time type checking, resolved at runtime.
Example:

dynamic x = 10;
x = "Hello";

- Record: For immutable data with value semantics.
- Class: For complex objects with reference semantics.
- Struct: For small, immutable data with value semantics.
Example:

record R(string Name);
class C { public string Name; }
struct S { public string Name; }

Interface methods are implicitly `public` to ensure consistent contract implementation across classes.
Example:

interface IExample {
    void Method(); // Implicitly public
}

A record is a reference type with value-based equality, immutability by default, and concise syntax for data objects.
Example:

record Person(string Name, int Age);

An anonymous function is a method without a name, typically defined using delegates or lambda expressions.
Example:

Func square = x => x * x;

- Thread: Low-level, OS-managed, resource-intensive.
- Task: High-level, managed by Task Parallel Library, supports async/await.
Example:

Task.Run(() => Console.WriteLine("Task"));
new Thread(() => Console.WriteLine("Thread")).Start();

`IDisposable` enables deterministic resource cleanup (e.g., file handles) using the `Dispose` method, often with `using`.
Example:

class Resource : IDisposable {
    public void Dispose() { }
}
using (var r = new Resource()) { }

A sealed class cannot be inherited, preventing further derivation.
Example:

sealed class MyClass { }

Lambda expressions are concise anonymous functions using `=>` syntax, often used with delegates or LINQ.
Example:

Func square = x => x * x;

- Overloading: Same method name, different parameters in the same class.
- Overriding: Redefining a virtual method in a derived class.
Example:

class Base {
    public virtual void Method() { }
    public void Method(int x) { }
}
class Derived : Base {
    public override void Method() { }
}

Encapsulation is implemented using private fields and public properties/methods to control access.
Example:

class BankAccount {
    private decimal balance;
    public decimal Balance { get => balance; }
}

Reflection allows inspecting and manipulating types, methods, and properties at runtime.
Example:

Type type = typeof(string);
Console.WriteLine(type.FullName);

The `??` operator returns the left operand if not null, otherwise the right operand.
Example:

string s = null;
string result = s ?? "Default";

Use the `sealed` keyword to prevent overriding methods or classes.
Example:

class Base {
    public virtual void Method() { }
}
class Derived : Base {
    public sealed override void Method() { }
}

- Interface: Only signatures, supports multiple inheritance.
- Abstract Class: Can include implementation, single inheritance.
Example:

interface IAnimal {
    void Speak();
}
abstract class Animal {
    public abstract void Speak();
}

A destructor (`~ClassName`) cleans up resources before garbage collection. Use rarely, prefer `IDisposable` for deterministic cleanup.
Example:

class Resource {
    ~Resource() { }
}

- const: Compile-time constant, cannot change.
- readonly: Runtime constant, set in constructor.
Example:

class MyClass {
    const int C = 10;
    readonly int R;
    public MyClass() { R = 20; }
}

Anonymous types are immutable, compiler-generated types for temporary data, created using `new { }`.
Example:

var anon = new { Name = "Alice", Age = 30 };

C# code is compiled into Intermediate Language (IL) by the C# compiler, then JIT-compiled to machine code by the CLR at runtime.

- throw: Preserves the original stack trace.
- throw ex: Resets the stack trace to the current point.
Example:

try {
    throw new Exception("Error");
} catch (Exception ex) {
    throw; // Preserves stack trace
}

- object: Type-safe, requires casting.
- dynamic: Type checked at runtime, no casting needed.
Example:

object o = "Hello";
string s = (string)o;
dynamic d = "Hello";
s = d;

- ==: Compares references for reference types, values for value types.
- Equals(): Compares content, can be overridden.
Example:

string s1 = "Hello";
string s2 = "Hello";
Console.WriteLine(s1 == s2); // True
Console.WriteLine(s1.Equals(s2)); // True

A virtual method can be overridden in a derived class, enabling polymorphism.
Example:

class Base {
    public virtual void Method() { }
}
class Derived : Base {
    public override void Method() { }
}

- Namespace Import: Access types without full qualification.
- Resource Management: Ensures `IDisposable` objects are disposed.
Example:

using System;
using (var stream = new FileStream("file.txt", FileMode.Open)) { }

- Virtual: Has default implementation, optional override.
- Abstract: No implementation, must be overridden.
Example:

abstract class Base {
    public virtual void V() { }
    public abstract void A();
}
class Derived : Base {
    public override void A() { }
}

Extension methods add functionality to existing types using static methods in a static class.
Example:

static class StringExtensions {
    public static string Reverse(this string s) => new string(s.Reverse().ToArray());
}
string s = "Hello".Reverse();

- ref: Parameter must be initialized before passing, can be read/write.
- out: Must be assigned in method, cannot be read before assignment.
Example:

void Method(ref int a, out int b) {
    a = a + 1;
    b = 10;
}

Pointer types in C# (`*`) allow direct memory access in `unsafe` contexts, used for performance-critical code.
Example:

unsafe {
    int x = 10;
    int* p = &x;
}

An `internal` member is accessible only within the same assembly.
Example:

internal class MyClass {
    internal int X;
}

Yes, use the `params` keyword to accept a variable number of arguments.
Example:

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

Indexers allow objects to be indexed like arrays using `this` keyword.
Example:

class MyCollection {
    private int[] data = new int[10];
    public int this[int i] {
        get => data[i];
        set => data[i] = value;
    }
}

- Dispose: Deterministic cleanup via `IDisposable`.
- Finalize: Non-deterministic cleanup via destructor, called by GC.
Example:

class Resource : IDisposable {
    public void Dispose() { }
    ~Resource() { }
}

- Where: Filters elements based on a condition.
- Select: Projects elements into a new form.
Example:

var numbers = new[] { 1, 2, 3, 4 };
var even = numbers.Where(n => n % 2 == 0);
var doubled = numbers.Select(n => n * 2);

- Func: Predefined delegate with return type.
- delegate: Custom delegate type definition.
Example:

Func f = s => s.ToUpper();
delegate string MyDelegate(string s);

A static constructor initializes static members, called automatically before first use.
Example:

class MyClass {
    static MyClass() { }
}

Check if a number is a Fibonacci number by generating terms or using the property that a number is Fibonacci if 5n^2 + 4 or 5n^2 - 4 is a perfect square.
Example:

bool IsFibonacci(int n) {
    int a = 0, b = 1;
    while (a < n) {
        int temp = a;
        a = b;
        b = temp + b;
    }
    return a == n;
}

Boxing a nullable type boxes the underlying value if it has one; if null, it boxes to null. Unboxing requires type matching.
Example:

int? x = 10;
object o = x; // Boxed to int
int? y = (int?)o;

The `yield` keyword creates an iterator, returning elements one at a time, useful for lazy evaluation.
Example:

IEnumerable GetNumbers() {
    yield return 1;
    yield return 2;
}

Yes, C# supports operator overloading using the `operator` keyword.
Example:

class Vector {
    public int X;
    public static Vector operator +(Vector a, Vector b) => new Vector { X = a.X + b.X };
}

- Interface: Contract, no implementation.
- Abstract Class: Partial implementation, single inheritance.
- Sealed Class: No inheritance.
- Static Class: Only static members.
- Partial Class: Split definition.
Example:

interface I { }
abstract class A { }
sealed class S { }
static class T { }
partial class P { }

C# supports multiple inheritance only through interfaces, not classes.
Example:

interface I1 { }
interface I2 { }
class C : I1, I2 { }

The `lock` statement ensures thread-safe access to shared resources.
Example:

object sync = new object();
lock (sync) {
    // Critical section
}

- SystemException: Base for system-related exceptions.
- ApplicationException: Intended for user-defined exceptions, though not strictly enforced.

- IEnumerable: Lazy, read-only iteration.
- List: In-memory, mutable collection.
Use `IEnumerable` for streaming, `List` for modification.
Example:

IEnumerable numbers = new List { 1, 2, 3 };

Overload by differing in number, type, or order of parameters.
Example:

class Calculator {
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
}

Use delegates for callbacks, event handling, or passing methods as parameters.
Example:

delegate void MyDelegate();
MyDelegate d = () => Console.WriteLine("Hello");

- is: Checks if an object is of a type.
- as: Casts if compatible, returns null if not.
Example:

object o = "Hello";
if (o is string) { }
string s = o as string;

`protected internal` members are accessible within the same assembly or derived classes.
Example:

class MyClass {
    protected internal int X;
}

Use `ArrayList` for dynamic sizing and mixed types, arrays for fixed-size, type-safe data.
Example:

ArrayList list = new ArrayList();
list.Add(1);
list.Add("Hello");

- `==`: Reference or value equality.
- `Equals()`: Content equality.
- `ReferenceEquals()`: Reference identity.
- `IEquatable`: Custom equality.
Example:

string s1 = "Hello";
string s2 = "Hello";
Console.WriteLine(s1.Equals(s2));

- CopyTo(): Copies elements to an existing array.
- Clone(): Creates a new array with copied elements.
Example:

int[] a = { 1, 2 };
int[] b = new int[2];
a.CopyTo(b, 0);
int[] c = (int[])a.Clone();

- Func: Returns a value.
- Action: No return value.
- Predicate: Returns bool.
Example:

Func f = x => x * 2;
Action a = x => Console.WriteLine(x);
Predicate p = x => x > 0;