C#.

A value type holds its data directly, while a reference type holds a reference to an object on the heap. Assigning a value type copies the whole value, and assigning a reference type copies only the reference.

Changing one copy of a value type leaves the other copy alone. Two reference-type variables can point at the same object, so a change made through one shows up through the other.

• Value types include int, bool and char. Every struct and enum is a value type too.
• Reference types include any class and string. Arrays and delegates are reference types too.

Value types default to zero, false or null in every field. Reference types default to null.

A local value-type variable usually sits on the stack, but a value-type field lives inside its containing object, on the heap.

A const is fixed at compile time, while a readonly field is fixed at run time, when its object or type is initialized.

• A const must be initialized where it is declared and never changes. It is implicitly static and holds only primitive types, string literals or null.
• A readonly field is set in its declaration or a constructor, so each instance can get its own value. It can be instance or static and hold any type.

For a reference type, readonly fixes only the reference. The object it points to can still change.

The compiler copies a const value into every caller, so changing it means recompiling those callers. A readonly value is read at run time. Use const for values that never change between versions, and readonly for values known only at run time.

public class Example
{
    const int MAX_SIZE = 100;           // Compile-time constant
    readonly DateTime createdDate;      // Runtime constant
    public Example()
    {
        createdDate = DateTime.Now;     // Can set in constructor
    }
}

A namespace groups related types under a name, such as MyCompany.DataAccess, so two types can share a name without clashing.

Namespaces are hierarchical. That lets you organize a codebase by area and keeps type names short and readable. Code refers to a type by its full name, or imports the namespace with a using directive.

namespace MyCompany.DataAccess
{
    public class DatabaseConnection { }
}
namespace MyCompany.UI
{
    public class DatabaseConnection { } // Same name, different namespace
}

Namespaces only affect names. They do not control loading, because the runtime loads code by assembly, and one assembly can hold many namespaces.

var declares an implicitly typed local variable, whose type the compiler infers from the initializer. The variable is still strongly typed, and its type is fixed at compile time.

It only works for local variables initialized where they are declared. Use it when the type is obvious from the right side, like new List<int>(). It is required for anonymous types, which have no name you can write. It also shortens LINQ queries with long type names. Avoid it when the type is not clear from the code.

var number = 42;           // int
var text = "Hello";        // string
var list = new List<int>(); // List<int>
// Required for anonymous types
var person = new { Name = "John", Age = 30 };

Encapsulation bundles data with its methods and hides the internals, and inheritance builds a new class from an existing one to reuse its code. Polymorphism lets code use different types through one common type, and abstraction shows only the essential features.

C# has a language feature for each pillar:

1. For encapsulation, access modifiers like private, plus properties.
2. For inheritance, a single base class, as in class Car : Vehicle.
3. For polymorphism, virtual and override methods and interfaces.
4. For abstraction, abstract classes and interfaces.

Overloading gives several methods one name with different parameters, and the compiler picks one at compile time. Overriding replaces a base class method in a derived class, and the runtime picks one based on the object's actual type.

The compiler chooses an overload from the argument types, so overloading is compile-time polymorphism. Overloads can live in the same class, like the two Add methods below. The return type alone cannot tell overloads apart.

Overriding needs virtual or abstract on the base method and override in the derived class. A Shape variable holding a Circle runs Circle.GetArea, so overriding is runtime polymorphism.

Use overloads for the same operation on different inputs. Use overriding to change behavior in a subclass.

// Overloading
public class Calculator
{
    public int Add(int a, int b) { return a + b; }
    public double Add(double a, double b) { return a + b; }
}
// Overriding
public class Shape
{
    public virtual double GetArea() { return 0; }
}
public class Circle : Shape
{
    private double radius;
    public override double GetArea() { return Math.PI * radius * radius; }
}

Access modifiers control which code can use a type or member.

• public is accessible from anywhere.
• private is accessible only inside the containing class.
• protected is accessible in the class and its derived classes.
• internal is accessible anywhere in the same assembly.
• protected internal is accessible in the same assembly, or from derived classes in any assembly.
• private protected is accessible only from derived classes in the same assembly.

Members of a class default to private, and top-level types default to internal. Pick the most restrictive one that works.

A constructor is a special method that runs when an object is created and sets up its state. It has the class name and no return type.

• A default constructor takes no parameters. The compiler adds one only when the class declares no constructor.
• A parameterized constructor takes values to initialize the object.
• A static constructor initializes static members. It runs once per type, before first use.
• A private constructor stops outside code from creating instances, as in a singleton.
• C# has no built-in copy constructor, so you write one yourself.

public class Person
{
    // Parameterized constructor
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    // Static constructor
    static Person()
    {
        // Initialize static members
    }
}

A nullable value type, written int?, lets a value type hold null as well as its normal values. It is shorthand for Nullable<int>, a struct with a HasValue flag and a Value property.

It fits data that can be missing, like a database column that allows NULL or an optional form field.

Check HasValue before reading Value, because reading Value when it holds nothing throws an InvalidOperationException. The ?? operator supplies a fallback instead, and GetValueOrDefault() returns the type's default.

int? nullableInt = null;
bool? nullableBool = null;
// Checking for null
if (nullableInt.HasValue)
{
    int value = nullableInt.Value;
}
// Null coalescing operator
int result = nullableInt ?? 0; // Use 0 if null

Do not confuse these with nullable reference types like string?, which are compile-time annotations only.

A string is immutable, so every change creates a new string object. A StringBuilder is mutable and appends into an internal buffer, so repeated changes avoid those extra objects.

Concatenating in a loop shows the cost. Each += on a string copies all the text built so far, so the total work grows with the square of the length. StringBuilder keeps one buffer and only reallocates when its capacity runs out.

Use string for a few concatenations, where the difference is too small to matter. Use StringBuilder when you build text in a loop or across many steps.

Immutability also makes a string safe to share across threads. A StringBuilder is not thread-safe, so one thread should own it.

// Inefficient - creates multiple string objects
string result = "";
for (int i = 0; i < 1000; i++)
{
    result += i.ToString(); // Creates new string each time
}
// Efficient - uses internal buffer
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
{
    sb.Append(i); // Modifies existing buffer
}
string result2 = sb.ToString();

An implicit conversion happens automatically because the compiler knows it is safe, like int to double. An explicit conversion needs a cast, like (int)largeValue, because the value may not fit.

Implicit conversions go from a smaller type to a larger one, so the value never overflows. They are not always exact, though. Converting int to float or long to double can lose precision, while keeping the magnitude.

Explicit conversions go from larger to smaller types, or between types that are not directly compatible. They can lose data, as when a cast drops the decimal part of a double. In a checked context they can also throw an OverflowException.

The Convert class handles conversions a cast cannot do, like turning the string "123" into an int.

// Implicit conversion
int intValue = 123;
double doubleValue = intValue; // Automatic conversion
// Explicit conversion
double largeValue = 123.456;
int smallValue = (int)largeValue; // Manual cast, loses decimal part
// Using Convert class
string numberString = "123";
int convertedValue = Convert.ToInt32(numberString);

Parse() returns the value and throws on invalid input, while TryParse() returns a bool for success and passes the value out through an out parameter.

Use Parse when invalid input means a bug, such as data your own code produced. Use TryParse for input you do not control, like user input or file contents. It avoids the cost of throwing and catching an exception for a failure you expect.

int.Parse throws a FormatException for text that is not a number, and an OverflowException when the number is out of range. On failure, TryParse sets the out value to its default, which is 0 for int. Most built-in value types have both methods, including DateTime and Guid.

// Parse - throws exception on failure
try
{
    int value1 = int.Parse("123");
    int value2 = int.Parse("abc"); // Throws FormatException
}
catch (FormatException ex) { }
// TryParse - safe conversion
if (int.TryParse("123", out int value3))
{
    // Conversion successful
}
else
{
    // Conversion failed, value3 is 0
}

An array has a fixed size, while ArrayList and List<T> grow as you add items. Arrays and List<T> are type-safe, and ArrayList is not.

ArrayList stores everything as object. Adding an int boxes it, and nothing stops you mixing strings and numbers in one list. The mistake shows up at run time as a failed cast. List<T> is generic, so the compiler checks every Add, and at run time it stores value types without boxing.

All three use zero-based indexing. Prefer List<T> in new code, and an array when the size is known and fixed.

// Array
int[] array = new int[5];
// ArrayList (avoid)
ArrayList arrayList = new ArrayList();
arrayList.Add(1);       // Boxing occurs
arrayList.Add("text");  // No compile-time type checking
// List<T> (preferred)
List<int> list = new List<int>();
list.Add(1);           // No boxing
// list.Add("text");   // Compile-time error

The core generic collections are List<T>, Dictionary<TKey, TValue> and HashSet<T>, with queues, stacks and sorted versions for special cases. They live in System.Collections.Generic, are type-safe, and store value types without boxing.

• List<T> is a dynamic array, and LinkedList<T> is a doubly linked list.
• HashSet<T> holds unique items with fast lookup, and SortedSet<T> keeps them sorted.
• Dictionary<TKey, TValue> maps keys to values with fast lookup, and SortedDictionary<TKey, TValue> keeps the keys sorted.
• Queue<T> is first in, first out, and Stack<T> is last in, first out.

For shared access across threads, ConcurrentDictionary<TKey, TValue> in System.Collections.Concurrent is the thread-safe dictionary.